home *** CD-ROM | disk | FTP | other *** search
/ Hot Super Models / Hot Super Models.iso / unix / x11 / xv200.tar / xv-2.00 / unsupt / VMS / XV.DIFF < prev   
Text File  |  1992-01-01  |  81KB  |  3,078 lines
  1. *** disk$vis:[xv.orig]bggen.c
  2. --- bggen.c
  3. **************
  4. *** 29,34
  5.   #define DEFSIZE 1024
  6.   #define MAXCOLS  128
  7.   
  8.   struct color { int r,g,b; int y; } cols[MAXCOLS], *cur, *nex;
  9.   
  10.   int bmask[8] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
  11. --- 29,37 -----
  12.   #define DEFSIZE 1024
  13.   #define MAXCOLS  128
  14.   
  15. + #ifdef VMS
  16. + struct color { int r,g,b; int y; } colors[MAXCOLS], *cur, *nex;
  17. + #else
  18.   struct color { int r,g,b; int y; } cols[MAXCOLS], *cur, *nex;
  19.   #endif
  20.   
  21. **************
  22. *** 30,35
  23.   #define MAXCOLS  128
  24.   
  25.   struct color { int r,g,b; int y; } cols[MAXCOLS], *cur, *nex;
  26.   
  27.   int bmask[8] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
  28.   
  29. --- 33,39 -----
  30.   struct color { int r,g,b; int y; } colors[MAXCOLS], *cur, *nex;
  31.   #else
  32.   struct color { int r,g,b; int y; } cols[MAXCOLS], *cur, *nex;
  33. + #endif
  34.   
  35.   int bmask[8] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
  36.   
  37. **************
  38. *** 44,49
  39.     int bits = 8;
  40.     int r, g, b;
  41.   
  42.     cnt = 0;  numcols = 0;
  43.     for (i=1; i<argc; i++) {
  44.       if (!strcmp(argv[i],"-s")) high = atoi(argv[++i]);
  45. --- 48,56 -----
  46.     int bits = 8;
  47.     int r, g, b;
  48.   
  49. + #ifdef VMS
  50. +   getredirection (&argc, &argv);
  51. + #endif
  52.     cnt = 0;  numcols = 0;
  53.     for (i=1; i<argc; i++) {
  54.       if (!strcmp(argv[i],"-s")) high = atoi(argv[++i]);
  55. **************
  56. *** 56,61
  57.   
  58.       else {
  59.         switch (cnt) {
  60.         case 0:  cols[numcols].r = atoi(argv[i]);  break;
  61.         case 1:  cols[numcols].g = atoi(argv[i]);  break;
  62.         case 2:  cols[numcols].b = atoi(argv[i]);  break;
  63. --- 63,73 -----
  64.   
  65.       else {
  66.         switch (cnt) {
  67. + #ifdef VMS
  68. +       case 0:  colors[numcols].r = atoi(argv[i]);  break;
  69. +       case 1:  colors[numcols].g = atoi(argv[i]);  break;
  70. +       case 2:  colors[numcols].b = atoi(argv[i]);  break;
  71. + #else
  72.         case 0:  cols[numcols].r = atoi(argv[i]);  break;
  73.         case 1:  cols[numcols].g = atoi(argv[i]);  break;
  74.         case 2:  cols[numcols].b = atoi(argv[i]);  break;
  75. **************
  76. *** 59,64
  77.         case 0:  cols[numcols].r = atoi(argv[i]);  break;
  78.         case 1:  cols[numcols].g = atoi(argv[i]);  break;
  79.         case 2:  cols[numcols].b = atoi(argv[i]);  break;
  80.         }
  81.         cnt++;
  82.   
  83. --- 71,77 -----
  84.         case 0:  cols[numcols].r = atoi(argv[i]);  break;
  85.         case 1:  cols[numcols].g = atoi(argv[i]);  break;
  86.         case 2:  cols[numcols].b = atoi(argv[i]);  break;
  87. + #endif
  88.         }
  89.         cnt++;
  90.   
  91. **************
  92. *** 89,94
  93.     if (numcols==1) {
  94.       for (i=0; i<high; i++) 
  95.         for (j=0; j<wide; j++)
  96.       printf("%d %d %d\n",cols[0].r,cols[0].g,cols[0].b);
  97.     }
  98.     else {
  99. --- 102,110 -----
  100.     if (numcols==1) {
  101.       for (i=0; i<high; i++) 
  102.         for (j=0; j<wide; j++)
  103. + #ifdef VMS
  104. +     printf("%d %d %d\n",colors[0].r,colors[0].g,colors[0].b);
  105. + #else
  106.       printf("%d %d %d\n",cols[0].r,cols[0].g,cols[0].b);
  107.   #endif
  108.     }
  109. **************
  110. *** 90,95
  111.       for (i=0; i<high; i++) 
  112.         for (j=0; j<wide; j++)
  113.       printf("%d %d %d\n",cols[0].r,cols[0].g,cols[0].b);
  114.     }
  115.     else {
  116.   
  117. --- 106,112 -----
  118.       printf("%d %d %d\n",colors[0].r,colors[0].g,colors[0].b);
  119.   #else
  120.       printf("%d %d %d\n",cols[0].r,cols[0].g,cols[0].b);
  121. + #endif
  122.     }
  123.     else {
  124.   
  125. **************
  126. *** 95,100
  127.   
  128.       /* fill in 'y' field of cols[] */
  129.       for (i=0; i<numcols; i++)
  130.         cols[i].y = ((high-1) * i) / (numcols-1);
  131.   
  132.       cur = &cols[0];  nex = cur+1;
  133. --- 112,120 -----
  134.   
  135.       /* fill in 'y' field of cols[] */
  136.       for (i=0; i<numcols; i++)
  137. + #ifdef VMS
  138. +       colors[i].y = ((high-1) * i) / (numcols-1);
  139. + #else
  140.         cols[i].y = ((high-1) * i) / (numcols-1);
  141.   #endif
  142.   
  143. **************
  144. *** 96,101
  145.       /* fill in 'y' field of cols[] */
  146.       for (i=0; i<numcols; i++)
  147.         cols[i].y = ((high-1) * i) / (numcols-1);
  148.   
  149.       cur = &cols[0];  nex = cur+1;
  150.   
  151. --- 116,122 -----
  152.         colors[i].y = ((high-1) * i) / (numcols-1);
  153.   #else
  154.         cols[i].y = ((high-1) * i) / (numcols-1);
  155. + #endif
  156.   
  157.   #ifdef VMS
  158.       cur = &colors[0];  nex = cur+1;
  159. **************
  160. *** 97,102
  161.       for (i=0; i<numcols; i++)
  162.         cols[i].y = ((high-1) * i) / (numcols-1);
  163.   
  164.       cur = &cols[0];  nex = cur+1;
  165.   
  166.       for (i=0; i<high; i++) {
  167. --- 118,126 -----
  168.         cols[i].y = ((high-1) * i) / (numcols-1);
  169.   #endif
  170.   
  171. + #ifdef VMS
  172. +     cur = &colors[0];  nex = cur+1;
  173. + #else
  174.       cur = &cols[0];  nex = cur+1;
  175.   #endif
  176.   
  177. **************
  178. *** 98,103
  179.         cols[i].y = ((high-1) * i) / (numcols-1);
  180.   
  181.       cur = &cols[0];  nex = cur+1;
  182.   
  183.       for (i=0; i<high; i++) {
  184.         /* advance to next pair of colors if we're outside region */
  185. --- 122,128 -----
  186.       cur = &colors[0];  nex = cur+1;
  187.   #else
  188.       cur = &cols[0];  nex = cur+1;
  189. + #endif
  190.   
  191.       for (i=0; i<high; i++) {
  192.         /* advance to next pair of colors if we're outside region */
  193. *** disk$vis:[xv.orig]imakefile.
  194. --- imakefile.
  195. **************
  196. *** 75,81
  197.   
  198.   
  199.   #if defined(SCOArchitecture)
  200. ! DEFINES= -DPOSIX -DNOITIMER
  201.   SYS_LIBRARIES=        $(XLIB) -lm -lc -lx
  202.   #else
  203.   SYS_LIBRARIES=        $(XLIB) -lm
  204. --- 75,81 -----
  205.   
  206.   
  207.   #if defined(SCOArchitecture)
  208. ! SCO_DEFINES= -DPOSIX -DNOITIMER
  209.   SYS_LIBRARIES=        $(XLIB) -lm -lc -lx
  210.   #else
  211.   SYS_LIBRARIES=        $(XLIB) -lm
  212. **************
  213. *** 81,88
  214.   SYS_LIBRARIES=        $(XLIB) -lm
  215.   #endif
  216.   
  217. ! DEFINES= $(DEFINES) $(UNIX) $(NEED_DIRENT) $(BROKECOLS) \
  218. !      $(VPRINTF) $(TIMERS) $(ATT) $(USEMEM)
  219.   
  220.   SYS_LIBRARIES=    -lX11 -lm
  221.   
  222. --- 81,87 -----
  223.   SYS_LIBRARIES=        $(XLIB) -lm
  224.   #endif
  225.   
  226. ! JPEGDIR = $(HOME)/jpeg
  227.   
  228.   INCLUDES= -I$(JPEGDIR)
  229.   
  230. **************
  231. *** 84,89
  232.   DEFINES= $(DEFINES) $(UNIX) $(NEED_DIRENT) $(BROKECOLS) \
  233.        $(VPRINTF) $(TIMERS) $(ATT) $(USEMEM)
  234.   
  235.   SYS_LIBRARIES=    -lX11 -lm
  236.   
  237.   BITMAPS = bitmaps/grasp bitmaps/penn bitmaps/down bitmaps/down1 \
  238. --- 83,93 -----
  239.   
  240.   JPEGDIR = $(HOME)/jpeg
  241.   
  242. + INCLUDES= -I$(JPEGDIR)
  243. + 
  244. + DEFINES= $(SCO_DEFINES) $(UNIX) $(NEED_DIRENT) $(BROKECOLS) \
  245. +      $(VPRINTF) $(TIMERS) $(ATT) $(USEMEM)
  246. + 
  247.   SYS_LIBRARIES=    -lX11 -lm
  248.   
  249.   BITMAPS = bitmaps/grasp bitmaps/penn bitmaps/down bitmaps/down1 \
  250. **************
  251. *** 96,101
  252.             bitmaps/fc_left1m bitmaps/fc_right1 bitmaps/fc_right1m \
  253.         bitmaps/icon
  254.   
  255.   SRCS1 =    xv.c xv24to8.c xvbutt.c xvctrl.c xvdir.c xvfish.c xvgam.c\
  256.       xvgif.c xvgifwr.c xvinfo.c xvmisc.c xvpbm.c xvpm.c xvscrl.c\
  257.       xvxbm.c vprintf.c
  258. --- 100,111 -----
  259.             bitmaps/fc_left1m bitmaps/fc_right1 bitmaps/fc_right1m \
  260.         bitmaps/icon
  261.   
  262. + JOBJS =    $(JPEGDIR)/jerror.o $(JPEGDIR)/jrdjfif.o $(JPEGDIR)/jdcolor.o \
  263. +     $(JPEGDIR)/jdhuff.o $(JPEGDIR)/jdmaster.o $(JPEGDIR)/jdmcu.o \
  264. +     $(JPEGDIR)/jdpipe.o $(JPEGDIR)/jdsample.o $(JPEGDIR)/jrevdct.o \
  265. +     $(JPEGDIR)/jutils.o $(JPEGDIR)/jvirtmem.o $(JPEGDIR)/jbsmooth.o \
  266. +     $(JPEGDIR)/jquant1.o $(JPEGDIR)/jquant2.o
  267. + 
  268.   SRCS1 =    xv.c xv24to8.c xvbutt.c xvctrl.c xvdir.c xvfish.c xvgam.c\
  269.       xvgif.c xvgifwr.c xvinfo.c xvmisc.c xvpbm.c xvpm.c xvscrl.c\
  270.       xvxbm.c vprintf.c xvjpeg.c
  271. **************
  272. *** 98,104
  273.   
  274.   SRCS1 =    xv.c xv24to8.c xvbutt.c xvctrl.c xvdir.c xvfish.c xvgam.c\
  275.       xvgif.c xvgifwr.c xvinfo.c xvmisc.c xvpbm.c xvpm.c xvscrl.c\
  276. !     xvxbm.c vprintf.c
  277.   
  278.   OBJS1 =    xv.o xv24to8.o xvbutt.o xvctrl.o xvdir.o xvfish.o xvgam.o\
  279.       xvgif.o xvgifwr.o xvinfo.o xvmisc.o xvpbm.o xvpm.o xvscrl.o \
  280. --- 108,114 -----
  281.   
  282.   SRCS1 =    xv.c xv24to8.c xvbutt.c xvctrl.c xvdir.c xvfish.c xvgam.c\
  283.       xvgif.c xvgifwr.c xvinfo.c xvmisc.c xvpbm.c xvpm.c xvscrl.c\
  284. !     xvxbm.c vprintf.c xvjpeg.c
  285.   
  286.   OBJS1 =    xv.o xv24to8.o xvbutt.o xvctrl.o xvdir.o xvfish.o xvgam.o\
  287.       xvgif.o xvgifwr.o xvinfo.o xvmisc.o xvpbm.o xvpm.o xvscrl.o \
  288. **************
  289. *** 102,108
  290.   
  291.   OBJS1 =    xv.o xv24to8.o xvbutt.o xvctrl.o xvdir.o xvfish.o xvgam.o\
  292.       xvgif.o xvgifwr.o xvinfo.o xvmisc.o xvpbm.o xvpm.o xvscrl.o \
  293. !     xvxbm.o vprintf.o
  294.   
  295.   SRCS2=    bggen.c
  296.   OBJS2=    bggen.o
  297. --- 112,118 -----
  298.   
  299.   OBJS1 =    xv.o xv24to8.o xvbutt.o xvctrl.o xvdir.o xvfish.o xvgam.o\
  300.       xvgif.o xvgifwr.o xvinfo.o xvmisc.o xvpbm.o xvpm.o xvscrl.o \
  301. !     xvxbm.o vprintf.o xvjpeg.o $(JOBJS)
  302.   
  303.   SRCS2=    bggen.c
  304.   OBJS2=    bggen.o
  305. **************
  306. *** 109,114
  307.   
  308.   PROGRAMS= xv bggen
  309.   
  310.   ComplexProgramTarget_1(xv,,)
  311.   ComplexProgramTarget_2(bggen,,)
  312.   
  313. --- 119,128 -----
  314.   
  315.   PROGRAMS= xv bggen
  316.   
  317. + #define IHaveSubdirs
  318. + #define PassCDebugFlags
  319. + SUBDIRS= $(JPEGDIR)
  320. + MakeSubdirs($(SUBDIRS))
  321.   ComplexProgramTarget_1(xv,,)
  322.   ComplexProgramTarget_2(bggen,,)
  323.   
  324. *** disk$vis:[xv.orig]xv.c
  325. --- xv.c
  326. **************
  327. *** 53,58
  328.   #define PM      2
  329.   #define PBM     3
  330.   #define XBM     4
  331.   
  332.   static unsigned long rootbg, rootfg;  /* fg/bg for root border */
  333.   static int    waitsec = -1;     /* seconds between pics. -1=wait for event */
  334. --- 53,59 -----
  335.   #define PM      2
  336.   #define PBM     3
  337.   #define XBM     4
  338. + #define JFIF    5
  339.   
  340.   static unsigned long rootbg, rootfg;  /* fg/bg for root border */
  341.   static int    waitsec = -1;     /* seconds between pics. -1=wait for event */
  342. **************
  343. *** 97,102
  344.   static int  rd_int();
  345.   static int  rd_str();
  346.   static int  rd_flag();
  347.   
  348.   
  349.   
  350. --- 98,105 -----
  351.   static int  rd_int();
  352.   static int  rd_str();
  353.   static int  rd_flag();
  354. + static int  XvErrorHandler();
  355. + static int  rd_boolean();
  356.   
  357.   
  358.   
  359. **************
  360. *** 121,127
  361.     /*** variable Initialization                       ***/
  362.     /*****************************************************/
  363.   
  364. ! #ifdef SYSV
  365.     getcwd(initpath, sizeof(initpath));
  366.   #else
  367.     getwd(initpath);
  368. --- 124,130 -----
  369.     /*** variable Initialization                       ***/
  370.     /*****************************************************/
  371.   
  372. ! #if (defined(SYSV) || defined(SVR4) || defined(VMS))
  373.     getcwd(initpath, sizeof(initpath));
  374.   #else
  375.     getwd(initpath);
  376. **************
  377. *** 134,139
  378.     theImage = NULL;
  379.     LocalCmap = 0;
  380.     InitFSDTables();
  381.     cmd = rindex(argv[0],'/');
  382.     if (!cmd) cmd = argv[0]; else cmd++;
  383.   
  384. --- 137,146 -----
  385.     theImage = NULL;
  386.     LocalCmap = 0;
  387.     InitFSDTables();
  388. + #ifdef VMS
  389. +   getredirection (&argc, &argv);
  390. +   cmd = rindex(argv[0],']');
  391. + #else
  392.     cmd = rindex(argv[0],'/');
  393.   #endif
  394.     if (!cmd) cmd = argv[0]; else cmd++;
  395. **************
  396. *** 135,140
  397.     LocalCmap = 0;
  398.     InitFSDTables();
  399.     cmd = rindex(argv[0],'/');
  400.     if (!cmd) cmd = argv[0]; else cmd++;
  401.   
  402.   
  403. --- 142,148 -----
  404.     cmd = rindex(argv[0],']');
  405.   #else
  406.     cmd = rindex(argv[0],'/');
  407. + #endif
  408.     if (!cmd) cmd = argv[0]; else cmd++;
  409.   
  410.   
  411. **************
  412. *** 158,169
  413.     useroot = clrroot = noqcheck = rwcolor = fishrunning = 0;
  414.     fish = 0;
  415.   
  416. - #ifdef BROKEFREECOLS
  417. -   brokeFreeCols = 1;
  418. - #else
  419. -   brokeFreeCols = 0;
  420. - #endif
  421. - 
  422.     defaspect = normaspect = 1.0;
  423.   
  424.     mainW = dirW = infoW = ctrlW = gamW = NULL;
  425. --- 166,171 -----
  426.     useroot = clrroot = noqcheck = rwcolor = fishrunning = 0;
  427.     fish = 0;
  428.   
  429.     defaspect = normaspect = 1.0;
  430.   
  431.     mainW = dirW = infoW = ctrlW = gamW = NULL;
  432. **************
  433. *** 210,216
  434.     if (rd_str ("background"))    bgstr       = def_str;
  435.     if (rd_str ("black"))         blackstr    = def_str;
  436.     if (rd_int ("borderWidth"))   bwidth      = def_int;
  437. -   if (rd_flag("brokeFreeCols")) brokeFreeCols = def_int;
  438.     if (rd_flag("centerPic"))     centerpic   = def_int;
  439.     if (rd_str ("ctrlGeometry"))  ctrlgeom    = def_str;
  440.     if (rd_flag("ctrlMap"))       ctrlmap     = def_int;
  441. --- 212,217 -----
  442.     if (rd_str ("background"))    bgstr       = def_str;
  443.     if (rd_str ("black"))         blackstr    = def_str;
  444.     if (rd_int ("borderWidth"))   bwidth      = def_int;
  445.     if (rd_flag("centerPic"))     centerpic   = def_int;
  446.     if (rd_str ("ctrlGeometry"))  ctrlgeom    = def_str;
  447.     if (rd_flag("ctrlMap"))       ctrlmap     = def_int;
  448. **************
  449. *** 294,302
  450.       else if (!strncmp(argv[i],"-au",3))  /* autogamma */
  451.         autogamma++;
  452.   
  453. -     else if (!strncmp(argv[i],"-bf",3))  /* brokeFreeCols */
  454. -       brokeFreeCols = !brokeFreeCols;
  455. - 
  456.       else if (!strncmp(argv[i],"-bg",3)) /* background color */
  457.         { if (++i<argc) bgstr = argv[i]; }
  458.   
  459. --- 295,300 -----
  460.       else if (!strncmp(argv[i],"-au",3))  /* autogamma */
  461.         autogamma++;
  462.   
  463.       else if (!strncmp(argv[i],"-bg",3)) /* background color */
  464.         { if (++i<argc) bgstr = argv[i]; }
  465.   
  466. **************
  467. *** 711,716
  468.     /* set up fullname and basename */
  469.   
  470.     fullname = namelist[filenum];
  471.     tmp = rindex(fullname,'/');
  472.     if (!tmp) tmp = fullname; else tmp++;
  473.     strcpy(basename,tmp);
  474. --- 709,717 -----
  475.     /* set up fullname and basename */
  476.   
  477.     fullname = namelist[filenum];
  478. + #ifdef VMS
  479. +   tmp = rindex(fullname,']');
  480. + #else
  481.     tmp = rindex(fullname,'/');
  482.   #endif
  483.     if (!tmp) tmp = fullname; else tmp++;
  484. **************
  485. *** 712,717
  486.   
  487.     fullname = namelist[filenum];
  488.     tmp = rindex(fullname,'/');
  489.     if (!tmp) tmp = fullname; else tmp++;
  490.     strcpy(basename,tmp);
  491.     if (strlen(basename)>2 && strcmp(basename+strlen(basename)-2,".Z")==0) 
  492. --- 713,719 -----
  493.     tmp = rindex(fullname,']');
  494.   #else
  495.     tmp = rindex(fullname,'/');
  496. + #endif
  497.     if (!tmp) tmp = fullname; else tmp++;
  498.     strcpy(basename,tmp);
  499.     if (strlen(basename)>2 && strcmp(basename+strlen(basename)-2,".Z")==0) 
  500. **************
  501. *** 722,727
  502.     freename = 0;
  503.     if (fullname[0] != '/' && strcmp(fullname,STDINSTR)!=0) {
  504.       char *tmp;
  505.       tmp = (char *) malloc(strlen(fullname) + strlen(initpath) + 2);
  506.       if (!tmp) FatalError("malloc 'filename' failed");
  507.       sprintf(tmp,"%s/%s", initpath, fullname);
  508. --- 724,732 -----
  509.     freename = 0;
  510.     if (fullname[0] != '/' && strcmp(fullname,STDINSTR)!=0) {
  511.       char *tmp;
  512. + #ifdef VMS
  513. +     tmp = (char *) malloc(strlen(fullname) + 2);
  514. + #else
  515.       tmp = (char *) malloc(strlen(fullname) + strlen(initpath) + 2);
  516.   #endif
  517.       if (!tmp) FatalError("malloc 'filename' failed");
  518. **************
  519. *** 723,728
  520.     if (fullname[0] != '/' && strcmp(fullname,STDINSTR)!=0) {
  521.       char *tmp;
  522.       tmp = (char *) malloc(strlen(fullname) + strlen(initpath) + 2);
  523.       if (!tmp) FatalError("malloc 'filename' failed");
  524.       sprintf(tmp,"%s/%s", initpath, fullname);
  525.       fullname = tmp;
  526. --- 728,734 -----
  527.       tmp = (char *) malloc(strlen(fullname) + 2);
  528.   #else
  529.       tmp = (char *) malloc(strlen(fullname) + strlen(initpath) + 2);
  530. + #endif
  531.       if (!tmp) FatalError("malloc 'filename' failed");
  532.   #ifdef VMS
  533.       sprintf(tmp,"%s", fullname);
  534. **************
  535. *** 724,729
  536.       char *tmp;
  537.       tmp = (char *) malloc(strlen(fullname) + strlen(initpath) + 2);
  538.       if (!tmp) FatalError("malloc 'filename' failed");
  539.       sprintf(tmp,"%s/%s", initpath, fullname);
  540.       fullname = tmp;
  541.       freename = 1;
  542. --- 730,738 -----
  543.       tmp = (char *) malloc(strlen(fullname) + strlen(initpath) + 2);
  544.   #endif
  545.       if (!tmp) FatalError("malloc 'filename' failed");
  546. + #ifdef VMS
  547. +     sprintf(tmp,"%s", fullname);
  548. + #else
  549.       sprintf(tmp,"%s/%s", initpath, fullname);
  550.   #endif
  551.       fullname = tmp;
  552. **************
  553. *** 725,730
  554.       tmp = (char *) malloc(strlen(fullname) + strlen(initpath) + 2);
  555.       if (!tmp) FatalError("malloc 'filename' failed");
  556.       sprintf(tmp,"%s/%s", initpath, fullname);
  557.       fullname = tmp;
  558.       freename = 1;
  559.     }
  560. --- 734,740 -----
  561.       sprintf(tmp,"%s", fullname);
  562.   #else
  563.       sprintf(tmp,"%s/%s", initpath, fullname);
  564. + #endif
  565.       fullname = tmp;
  566.       freename = 1;
  567.     }
  568. **************
  569. *** 752,757
  570.     if (strcmp(filename,STDINSTR)==0) {
  571.       FILE *fp;
  572.   
  573.       strcpy(filename,"/tmp/xvXXXXXX");
  574.       mktemp(filename);
  575.   
  576. --- 762,770 -----
  577.     if (strcmp(filename,STDINSTR)==0) {
  578.       FILE *fp;
  579.   
  580. + #ifdef VMS
  581. +     strcpy(filename,"Sys$Disk:[]xvXXXXXX");
  582. + #else
  583.       strcpy(filename,"/tmp/xvXXXXXX");
  584.   #endif
  585.       mktemp(filename);
  586. **************
  587. *** 753,758
  588.       FILE *fp;
  589.   
  590.       strcpy(filename,"/tmp/xvXXXXXX");
  591.       mktemp(filename);
  592.   
  593.       fp = fopen(filename,"w");
  594. --- 766,772 -----
  595.       strcpy(filename,"Sys$Disk:[]xvXXXXXX");
  596.   #else
  597.       strcpy(filename,"/tmp/xvXXXXXX");
  598. + #endif
  599.       mktemp(filename);
  600.   
  601.       fp = fopen(filename,"w");
  602. **************
  603. *** 756,761
  604.       mktemp(filename);
  605.   
  606.       fp = fopen(filename,"w");
  607.       if (!fp) FatalError("can't write /tmp/xv****** file");
  608.       
  609.       while ( (i=getchar()) != EOF) putc(i,fp);
  610. --- 770,778 -----
  611.       mktemp(filename);
  612.   
  613.       fp = fopen(filename,"w");
  614. + #ifdef VMS
  615. +     if (!fp) FatalError("can't write Sys$Disk:[]xv****** file");
  616. + #else
  617.       if (!fp) FatalError("can't write /tmp/xv****** file");
  618.   #endif
  619.       
  620. **************
  621. *** 757,762
  622.   
  623.       fp = fopen(filename,"w");
  624.       if (!fp) FatalError("can't write /tmp/xv****** file");
  625.       
  626.       while ( (i=getchar()) != EOF) putc(i,fp);
  627.       fclose(fp);
  628. --- 774,780 -----
  629.       if (!fp) FatalError("can't write Sys$Disk:[]xv****** file");
  630.   #else
  631.       if (!fp) FatalError("can't write /tmp/xv****** file");
  632. + #endif
  633.       
  634.       while ( (i=getchar()) != EOF) putc(i,fp);
  635.       fclose(fp);
  636. **************
  637. *** 768,773
  638.   
  639.     fp=fopen(filename,"r");
  640.     if (!fp) {
  641.       SetISTR(ISTR_INFO,"Can't open '%s' -  %s",filename,sys_errlist[errno]);
  642.       Warning();
  643.       goto FAILED;
  644. --- 786,794 -----
  645.   
  646.     fp=fopen(filename,"r");
  647.     if (!fp) {
  648. + #ifdef VMS
  649. +     SetISTR(ISTR_INFO,"Can't open '%s'",filename);
  650. + #else
  651.       SetISTR(ISTR_INFO,"Can't open '%s' -  %s",filename,sys_errlist[errno]);
  652.   #endif
  653.       Warning();
  654. **************
  655. *** 769,774
  656.     fp=fopen(filename,"r");
  657.     if (!fp) {
  658.       SetISTR(ISTR_INFO,"Can't open '%s' -  %s",filename,sys_errlist[errno]);
  659.       Warning();
  660.       goto FAILED;
  661.     }
  662. --- 790,796 -----
  663.       SetISTR(ISTR_INFO,"Can't open '%s'",filename);
  664.   #else
  665.       SetISTR(ISTR_INFO,"Can't open '%s' -  %s",filename,sys_errlist[errno]);
  666. + #endif
  667.       Warning();
  668.       goto FAILED;
  669.     }
  670. **************
  671. *** 777,783
  672.     fclose(fp);
  673.   
  674.     filetype = UNKNOWN;
  675. !   if (strncmp(magicno,"GIF87",5)==0) filetype = GIF;
  676.   
  677.     else if (strncmp(magicno,"VIEW",4)==0 ||
  678.          strncmp(magicno,"WEIV",4)==0) filetype = PM;
  679. --- 799,805 -----
  680.     fclose(fp);
  681.   
  682.     filetype = UNKNOWN;
  683. !   if (strncmp(magicno,"GIF",3)==0) filetype = GIF;
  684.   
  685.     else if (magicno[0] == -1 && 
  686.          magicno[1] == -40 && 
  687. **************
  688. *** 779,784
  689.     filetype = UNKNOWN;
  690.     if (strncmp(magicno,"GIF87",5)==0) filetype = GIF;
  691.   
  692.     else if (strncmp(magicno,"VIEW",4)==0 ||
  693.          strncmp(magicno,"WEIV",4)==0) filetype = PM;
  694.   
  695. --- 801,810 -----
  696.     filetype = UNKNOWN;
  697.     if (strncmp(magicno,"GIF",3)==0) filetype = GIF;
  698.   
  699. +   else if (magicno[0] == -1 && 
  700. +        magicno[1] == -40 && 
  701. +        magicno[2] == -1) filetype = JFIF; 
  702. + 
  703.     else if (strncmp(magicno,"VIEW",4)==0 ||
  704.          strncmp(magicno,"WEIV",4)==0) filetype = PM;
  705.   
  706. **************
  707. *** 796,805
  708.     SetISTR(ISTR_INFO,"Loading '%s'...",basename);
  709.   
  710.     switch (filetype) {
  711. !   case GIF: i = LoadGIF(filename,ncols); break;
  712. !   case PM:  i = LoadPM (filename,ncols); break;
  713. !   case PBM: i = LoadPBM(filename,ncols); break;
  714. !   case XBM: i = LoadXBM(filename,ncols); break;
  715.     }
  716.     WaitCursor();
  717.   
  718. --- 822,834 -----
  719.     SetISTR(ISTR_INFO,"Loading '%s'...",basename);
  720.   
  721.     switch (filetype) {
  722. !   case GIF:  i = LoadGIF (filename,ncols); break;
  723. !   case PM:   i = LoadPM  (filename,ncols); break;
  724. !   case PBM:  i = LoadPBM (filename,ncols); break;
  725. !   case XBM:  i = LoadXBM (filename,ncols); break;
  726. ! /*  not avaiable yet
  727. !   case JFIF: i = LoadJFIF(filename,ncols); break;
  728. ! */
  729.     }
  730.     WaitCursor();
  731.   
  732. **************
  733. *** 960,969
  734.       XFreeColormap(theDisp,LocalCmap);
  735.       LocalCmap = 0;
  736.     }
  737. -   else if (!brokeFreeCols) {
  738. -     for (i=0; i<nfcols; i++) 
  739. -       XFreeColors(theDisp, theCmap, &freecols[i], 1, 0L);
  740. -   }
  741.     else {
  742.       for (i=0; i<nfcols; i++) {
  743.         int j;
  744. --- 989,994 -----
  745.       XFreeColormap(theDisp,LocalCmap);
  746.       LocalCmap = 0;
  747.     }
  748.     else {
  749.       XvFreeColors(theDisp, theCmap, freecols, 1, 0L, nfcols);
  750.     }
  751. **************
  752. *** 965,979
  753.         XFreeColors(theDisp, theCmap, &freecols[i], 1, 0L);
  754.     }
  755.     else {
  756. !     for (i=0; i<nfcols; i++) {
  757. !       int j;
  758. !       for (j=0; j<i; j++) {
  759. !         if (freecols[i] == freecols[j])   /* already been freed once */
  760. !       break;
  761. !       }
  762. !       if (j==i)      /* wasn't found in already-freed list */
  763. !         XFreeColors(theDisp, theCmap, &freecols[i], 1, 0L);
  764. !     }
  765.     }
  766.   
  767.     if (epic != cpic && epic != NULL) free(epic);
  768. --- 990,996 -----
  769.       LocalCmap = 0;
  770.     }
  771.     else {
  772. !     XvFreeColors(theDisp, theCmap, freecols, 1, 0L, nfcols);
  773.     }
  774.   
  775.     if (epic != cpic && epic != NULL) free(epic);
  776. **************
  777. *** 1791,1796
  778.      * twm where resize was giving 23 extra lines...
  779.      * should do no harm if this bug is not present.
  780.      */
  781.     XSync(theDisp,False);
  782.     XGetWindowAttributes(theDisp, mainW, &pxwa);
  783.     if (pxwa.height != xwa->height) {
  784. --- 1808,1814 -----
  785.      * twm where resize was giving 23 extra lines...
  786.      * should do no harm if this bug is not present.
  787.      */
  788. + #ifdef TWMKLUDGE
  789.     XSync(theDisp,False);
  790.     XGetWindowAttributes(theDisp, mainW, &pxwa);
  791.     if (pxwa.height != xwa->height) {
  792. **************
  793. *** 1803,1808
  794.       XResizeWindow(theDisp, mainW, xwa->width, 
  795.             xwa->height - (pxwa.height - xwa->height));
  796.     }
  797.   
  798.   }
  799.   
  800. --- 1821,1827 -----
  801.       XResizeWindow(theDisp, mainW, xwa->width, 
  802.             xwa->height - (pxwa.height - xwa->height));
  803.     }
  804. + #endif /* TWMKLUDGE */
  805.   
  806.   }
  807.   
  808. **************
  809. *** 2039,2044
  810.     /* returns true if there's a config event in which mainW changes size
  811.        in the event queue */
  812.   
  813.     foo = 0;
  814.     XCheckIfEvent(theDisp, &ev, IsConfig, &foo);
  815.     return foo;
  816. --- 2058,2064 -----
  817.     /* returns true if there's a config event in which mainW changes size
  818.        in the event queue */
  819.   
  820. +   XSync(theDisp, False);
  821.     foo = 0;
  822.     XCheckIfEvent(theDisp, &ev, IsConfig, &foo);
  823.     return foo;
  824. **************
  825. *** 2224,2233
  826.     /* returns '1' if successful.  result in def_str */
  827.     
  828.     if (def_str = XGetDefault(theDisp, PROGNAME, name)) {
  829. !     def_int = (strcmp(def_str, "on")==0) || 
  830. !               (strcmp(def_str, "1")==0) ||
  831. !           (strcmp(def_str, "true")==0) ||
  832. !           (strcmp(def_str, "yes")==0);
  833.       return 1;
  834.       }
  835.   
  836. --- 2244,2250 -----
  837.     /* returns '1' if successful.  result in def_str */
  838.     
  839.     if (def_str = XGetDefault(theDisp, PROGNAME, name)) {
  840. !     def_int = rd_boolean(def_str);
  841.       return 1;
  842.       }
  843.   
  844. **************
  845. *** 2234,2239
  846.     else return 0;
  847.   }
  848.       
  849.   
  850.   
  851.   
  852. --- 2251,2335 -----
  853.     else return 0;
  854.   }
  855.       
  856. + void XvFreeColors(display, colormap, pixels, npixels, planes, nfcols)
  857. +   Display       * display;
  858. +   Colormap        colormap;
  859. +   unsigned long * pixels;
  860. +   int             npixels;
  861. +   unsigned long   planes;
  862. +   int             nfcols;
  863. + {
  864. +   int i;
  865. + 
  866. +   XSetErrorHandler(XvErrorHandler); /* Handle X_FreeColors error messages */
  867. +   for (i=0; i<nfcols; i++) 
  868. +     XFreeColors(display, colormap, &pixels[i], npixels, planes);
  869. +   XSync(theDisp, False); /* Sync the display so that there won't be */
  870. +   XSetErrorHandler(0);   /* problems restoring the default error handler */
  871. + }
  872. + 
  873. + static int XvErrorHandler(display, err)
  874. + Display *display;
  875. + XErrorEvent *err;
  876. + {
  877. +   /* 
  878. +    * What should be done here?  Probably a check for request code 88
  879. +    * And a call to the default error handle under all other errors
  880. +    */
  881. + }  
  882. +   
  883. + /***********************************/
  884. + static int rd_boolean(value)
  885. + char *value;
  886. + {
  887. +   int   i;
  888. +   int   match;
  889. +  
  890. + #define MAXKEYWORDLEN   4  /* the strlen() of largest element in keywords[] */
  891. +  
  892. +   char  tmp[MAXKEYWORDLEN + 1];
  893. +   char *ptr;
  894. +   static char *keywords[] = {
  895. +     "1",
  896. +     "on",
  897. +     "yes",
  898. +     "true",
  899. +     (char *) 0
  900. +   };
  901. +  
  902. +   /* Will 'value' fit in 'tmp' */
  903. +   if (strlen(value) > MAXKEYWORDLEN)
  904. +   { /* Nope, must no be a valid value */
  905. +     return 0;
  906. +   }
  907. +   else
  908. +   { /* get a local copy of value */
  909. +     (void) strncpy(tmp, value, MAXKEYWORDLEN + 1);
  910. +   }
  911. +  
  912. +   /* convert the local copy to lower case */
  913. +   ptr = tmp;
  914. +   while (*ptr != '\0')
  915. +   {
  916. +     *ptr = isupper(*ptr) ? tolower(*ptr) : *ptr;
  917. +     ptr++;
  918. +   }
  919. + 
  920. +   /* search the array of keywords for a match */
  921. +   i = 0;
  922. +   match = 0;
  923. +   while (keywords[i] != (char *) 0)
  924. +   {
  925. +     if (strcmp(tmp, keywords[i]) == 0)
  926. +     {
  927. +       match = 1;
  928. +     }
  929. +     i++;
  930. +   }
  931. + 
  932. +   return(match);
  933. + }
  934. +   
  935.   
  936.   
  937.   
  938. *** disk$vis:[xv.orig]xv.h
  939. --- xv.h
  940. **************
  941. *** 30,35
  942.   #include <math.h>
  943.   #include <ctype.h>
  944.   #include <string.h>
  945.   extern int   errno;             /* this SHOULD be in errno.h */
  946.   extern char *sys_errlist[];     /* this SHOULD be in errno.h */
  947.   
  948. --- 30,38 -----
  949.   #include <math.h>
  950.   #include <ctype.h>
  951.   #include <string.h>
  952. + #ifdef VMS
  953. + #include <errno.h>
  954. + #else
  955.   extern int   errno;             /* this SHOULD be in errno.h */
  956.   extern char *sys_errlist[];     /* this SHOULD be in errno.h */
  957.   #endif
  958. **************
  959. *** 32,37
  960.   #include <string.h>
  961.   extern int   errno;             /* this SHOULD be in errno.h */
  962.   extern char *sys_errlist[];     /* this SHOULD be in errno.h */
  963.   
  964.   #ifndef __convexc__             /* Convex doesn't have <memory.h> */
  965.   #include <memory.h>             /* for 'memset()' prototype */
  966. --- 35,41 -----
  967.   #else
  968.   extern int   errno;             /* this SHOULD be in errno.h */
  969.   extern char *sys_errlist[];     /* this SHOULD be in errno.h */
  970. + #endif
  971.   
  972.   /* Convex and VMS doesn't have <memory.h> */
  973.   #if !(defined(__convexc__) || defined(VMS))
  974. **************
  975. *** 33,39
  976.   extern int   errno;             /* this SHOULD be in errno.h */
  977.   extern char *sys_errlist[];     /* this SHOULD be in errno.h */
  978.   
  979. ! #ifndef __convexc__             /* Convex doesn't have <memory.h> */
  980.   #include <memory.h>             /* for 'memset()' prototype */
  981.   #endif
  982.   
  983. --- 37,44 -----
  984.   extern char *sys_errlist[];     /* this SHOULD be in errno.h */
  985.   #endif
  986.   
  987. ! /* Convex and VMS doesn't have <memory.h> */
  988. ! #if !(defined(__convexc__) || defined(VMS))
  989.   #include <memory.h>             /* for 'memset()' prototype */
  990.   #endif
  991.   
  992. **************
  993. *** 38,45
  994.   #endif
  995.   
  996.   /* neither IBM AOS 4.3, Convex, nor BSD 4.3 on VAX have <malloc.h> */
  997. ! #if !defined(ibm032) && !defined(__convexc__) && \
  998. !     !(defined(vax) && !defined(ultrix))
  999.   #if defined(hp300) || defined(hp800)
  1000.   #include <sys/malloc.h>                /* it's in 'sys' on HPs*/
  1001.   #else
  1002. --- 43,49 -----
  1003.   #endif
  1004.   
  1005.   /* neither IBM AOS 4.3, Convex, nor BSD 4.3 on VAX have <malloc.h> */
  1006. ! #if !defined(ibm032) && !defined(__convexc__) && !(defined(vax) && !defined(ultrix))
  1007.   #if defined(hp300) || defined(hp800)
  1008.   #include <sys/malloc.h>                /* it's in 'sys' on HPs*/
  1009.   #else
  1010. **************
  1011. *** 52,57
  1012.   #define memcpy(d,s,l) bcopy(s,d,l)
  1013.   #endif
  1014.   
  1015.   
  1016.   #include <X11/Xos.h>
  1017.   #include <X11/Xlib.h>
  1018. --- 56,67 -----
  1019.   #define memcpy(d,s,l) bcopy(s,d,l)
  1020.   #endif
  1021.   
  1022. + #ifdef VMS
  1023. + #define bcopy(src,dst,len) memcpy(dst,src,len)
  1024. + #define unlink remove
  1025. + #define index(s,c) strchr(s,c)
  1026. + #define rindex(s,c) strrchr(s,c)
  1027. + #endif
  1028.   
  1029.   #include <X11/Xos.h>
  1030.   #include <X11/Xlib.h>
  1031. **************
  1032. *** 68,73
  1033.   #ifndef sgi              /* silicon graphics doesn't have timeb.h */
  1034.   #include <sys/timeb.h>
  1035.   #endif
  1036.   #include <signal.h>
  1037.   #if defined(sco) && !defined(NOTIMER)
  1038.   #include <sys/itimer.h>
  1039. --- 78,84 -----
  1040.   #ifndef sgi              /* silicon graphics doesn't have timeb.h */
  1041.   #include <sys/timeb.h>
  1042.   #endif
  1043. + #undef SIGCHLD
  1044.   #include <signal.h>
  1045.   #if defined(sco) && !defined(NOTIMER)
  1046.   #include <sys/itimer.h>
  1047. **************
  1048. *** 78,83
  1049.   #endif
  1050.   
  1051.   #ifdef NEEDSDIR
  1052.   #ifdef sco
  1053.   #include <sys/ndir.h>
  1054.   #define lstat stat
  1055. --- 89,95 -----
  1056.   #endif
  1057.   
  1058.   #ifdef NEEDSDIR
  1059. + #ifndef HPUX
  1060.   #ifdef sco
  1061.   #include <sys/ndir.h>
  1062.   #define lstat stat
  1063. **************
  1064. *** 86,91
  1065.   #include <sys/dir.h>
  1066.   #endif  /* ATT */
  1067.   #endif  /* sco */
  1068.   #include <sys/param.h>
  1069.   #include <sys/stat.h>
  1070.   #ifdef DIRENT
  1071. --- 98,105 -----
  1072.   #include <sys/dir.h>
  1073.   #endif  /* ATT */
  1074.   #endif  /* sco */
  1075. + #endif  /* not HPUX */
  1076. + #ifndef VMS
  1077.   #include <sys/param.h>
  1078.   #endif  /* not VMS */
  1079.   #include <sys/stat.h>
  1080. **************
  1081. *** 87,92
  1082.   #endif  /* ATT */
  1083.   #endif  /* sco */
  1084.   #include <sys/param.h>
  1085.   #include <sys/stat.h>
  1086.   #ifdef DIRENT
  1087.   #include <dirent.h>
  1088. --- 101,107 -----
  1089.   #endif  /* not HPUX */
  1090.   #ifndef VMS
  1091.   #include <sys/param.h>
  1092. + #endif  /* not VMS */
  1093.   #include <sys/stat.h>
  1094.   #ifdef DIRENT
  1095.   #ifdef VMS
  1096. **************
  1097. *** 89,94
  1098.   #include <sys/param.h>
  1099.   #include <sys/stat.h>
  1100.   #ifdef DIRENT
  1101.   #include <dirent.h>
  1102.   #endif
  1103.   #endif
  1104. --- 104,113 -----
  1105.   #endif  /* not VMS */
  1106.   #include <sys/stat.h>
  1107.   #ifdef DIRENT
  1108. + #ifdef VMS
  1109. + #include <descrip.h>
  1110. + #include "dirent.h"
  1111. + #else
  1112.   #include <dirent.h>
  1113.   #endif  /* VMS */
  1114.   #endif  /* DIRENT */
  1115. **************
  1116. *** 90,97
  1117.   #include <sys/stat.h>
  1118.   #ifdef DIRENT
  1119.   #include <dirent.h>
  1120. ! #endif
  1121. ! #endif
  1122.   
  1123.   #ifdef NEEDSVARARGS
  1124.   #include <varargs.h>
  1125. --- 109,117 -----
  1126.   #include "dirent.h"
  1127.   #else
  1128.   #include <dirent.h>
  1129. ! #endif  /* VMS */
  1130. ! #endif  /* DIRENT */
  1131. ! #endif  /* NEEDSDIR */
  1132.   
  1133.   #ifdef NEEDSVARARGS
  1134.   #include <varargs.h>
  1135. **************
  1136. *** 100,106
  1137.   /* signal macros */
  1138.   #ifdef SVR4
  1139.   #define HOLD_SIG         sighold(SIGALRM)  /* block ALRM sig from occurring */
  1140. ! #define RELEASE_SIG      sigrelse(SIGALRM) /* 
  1141.   #define PAUSE_SIG        sigpause(SIGALRM) /* sleep until ALRM signal */
  1142.   #else
  1143.   #define HOLD_SIG         sigblock(sigmask(SIGALRM))
  1144. --- 120,126 -----
  1145.   /* signal macros */
  1146.   #ifdef SVR4
  1147.   #define HOLD_SIG         sighold(SIGALRM)  /* block ALRM sig from occurring */
  1148. ! #define RELEASE_SIG      sigrelse(SIGALRM) /* */
  1149.   #define PAUSE_SIG        sigpause(SIGALRM) /* sleep until ALRM signal */
  1150.   #else
  1151.   #define HOLD_SIG         sigblock(sigmask(SIGALRM))
  1152. **************
  1153. *** 119,124
  1154.   #undef  PAUSE_SIG
  1155.   #define PAUSE_SIG     /* */
  1156.   #else
  1157.   #define UNCOMPRESS "/usr/ucb/uncompress"   /* for uncompressing .Z files */
  1158.   #endif
  1159.   
  1160. --- 139,148 -----
  1161.   #undef  PAUSE_SIG
  1162.   #define PAUSE_SIG     /* */
  1163.   #else
  1164. + #ifdef VMS
  1165. + #define MAXPATHLEN    500
  1166. + #define UNCOMPRESS "decompress"   /* for uncompressing .Z files */
  1167. + #endif  /* VMS */
  1168.   #define UNCOMPRESS "/usr/ucb/uncompress"   /* for uncompressing .Z files */
  1169.   #endif  /* i386 */
  1170.   
  1171. **************
  1172. *** 120,126
  1173.   #define PAUSE_SIG     /* */
  1174.   #else
  1175.   #define UNCOMPRESS "/usr/ucb/uncompress"   /* for uncompressing .Z files */
  1176. ! #endif
  1177.   
  1178.   #define PROGNAME  "xv"             /* used in resource database */
  1179.   
  1180. --- 144,150 -----
  1181.   #define UNCOMPRESS "decompress"   /* for uncompressing .Z files */
  1182.   #endif  /* VMS */
  1183.   #define UNCOMPRESS "/usr/ucb/uncompress"   /* for uncompressing .Z files */
  1184. ! #endif  /* i386 */
  1185.   
  1186.   #define PROGNAME  "xv"             /* used in resource database */
  1187.   
  1188. **************
  1189. *** 298,305
  1190.   #define RANGE(a,b,c) { if (a<b) a=b;  if (a>c) a=c; }
  1191.   
  1192.   /* PTINRECT returns '1' if x,y is in rect (inclusive) */
  1193. ! #define PTINRECT(x,y,rx,ry,rw,rh) \
  1194. !            ((x)>=(rx) && (y)>=(ry) && (x)<=(rx)+(rw) && (y)<=(ry)+(rh))
  1195.   
  1196.   /* MONO returns total intensity of r,g,b components */
  1197.   #define MONO(rd,gn,bl) (((rd)*11 + (gn)*16 + (bl)*5) >> 5)  /*.33R+ .5G+ .17B*/
  1198. --- 322,328 -----
  1199.   #define RANGE(a,b,c) { if (a<b) a=b;  if (a>c) a=c; }
  1200.   
  1201.   /* PTINRECT returns '1' if x,y is in rect (inclusive) */
  1202. ! #define PTINRECT(x,y,rx,ry,rw,rh) ((x)>=(rx) && (y)>=(ry) && (x)<=(rx)+(rw) && (y)<=(ry)+(rh))
  1203.   
  1204.   /* MONO returns total intensity of r,g,b components */
  1205.   #define MONO(rd,gn,bl) (((rd)*11 + (gn)*16 + (bl)*5) >> 5)  /*.33R+ .5G+ .17B*/
  1206. **************
  1207. *** 350,355
  1208.   
  1209.   WHERE unsigned long freecols[256]; /* list of pixel values to free */
  1210.   WHERE int           nfcols;        /* number of colors to free */
  1211.   WHERE unsigned long cols[256];     /* maps pic pixel values to X pixel vals */
  1212.   WHERE int           fc2pcol[256];  /* maps freecols into pic pixel values */
  1213.   WHERE int           numcols;       /* # of desired colors in picture */
  1214. --- 373,381 -----
  1215.   
  1216.   WHERE unsigned long freecols[256]; /* list of pixel values to free */
  1217.   WHERE int           nfcols;        /* number of colors to free */
  1218. + #ifdef VMS
  1219. + WHERE unsigned long colors[256];   /* maps pic pixel values to X pixel vals */
  1220. + #else
  1221.   WHERE unsigned long cols[256];     /* maps pic pixel values to X pixel vals */
  1222.   #endif
  1223.   WHERE int           fc2pcol[256];  /* maps freecols into pic pixel values */
  1224. **************
  1225. *** 351,356
  1226.   WHERE unsigned long freecols[256]; /* list of pixel values to free */
  1227.   WHERE int           nfcols;        /* number of colors to free */
  1228.   WHERE unsigned long cols[256];     /* maps pic pixel values to X pixel vals */
  1229.   WHERE int           fc2pcol[256];  /* maps freecols into pic pixel values */
  1230.   WHERE int           numcols;       /* # of desired colors in picture */
  1231.   WHERE int           ncols;         /* max # of (different) colors to alloc */
  1232. --- 377,383 -----
  1233.   WHERE unsigned long colors[256];   /* maps pic pixel values to X pixel vals */
  1234.   #else
  1235.   WHERE unsigned long cols[256];     /* maps pic pixel values to X pixel vals */
  1236. + #endif
  1237.   WHERE int           fc2pcol[256];  /* maps freecols into pic pixel values */
  1238.   WHERE int           numcols;       /* # of desired colors in picture */
  1239.   WHERE int           ncols;         /* max # of (different) colors to alloc */
  1240. **************
  1241. *** 370,376
  1242.                       noqcheck,      /* true if we should NOT do QuickCheck */
  1243.                       rwcolor,       /* true if we should use R/W color cells */
  1244.                       rwthistime,    /* true if we DID use R/W color cells */
  1245. -                     brokeFreeCols, /* true if server has broken XFreeColors */
  1246.                       fish,          /* turn on annoying fish */
  1247.                       fishrunning;   /* true if fish are in operation */
  1248.   
  1249. --- 397,402 -----
  1250.                       noqcheck,      /* true if we should NOT do QuickCheck */
  1251.                       rwcolor,       /* true if we should use R/W color cells */
  1252.                       rwthistime,    /* true if we DID use R/W color cells */
  1253.                       fish,          /* turn on annoying fish */
  1254.                       fishrunning;   /* true if fish are in operation */
  1255.   
  1256. **************
  1257. *** 428,433
  1258.   void WRotate(void);
  1259.   void InvCropRect(void);
  1260.   void MakeRootPic(void);
  1261.   
  1262.   /*************************** XVMISC.C ***************************/
  1263.   Window CreateWindow(char *, char *, unsigned int, unsigned int, 
  1264. --- 454,460 -----
  1265.   void WRotate(void);
  1266.   void InvCropRect(void);
  1267.   void MakeRootPic(void);
  1268. + void XvFreeColors(Display*, Colormap, unsigned long*, int, unsigned long, int);
  1269.   
  1270.   /*************************** XVMISC.C ***************************/
  1271.   Window CreateWindow(char *, char *, unsigned int, unsigned int, 
  1272. **************
  1273. *** 558,563
  1274.   int LoadXBM(char *, int);
  1275.   int WriteXBM(FILE *, byte *, int, int, char *);
  1276.   
  1277.   
  1278.   
  1279.   
  1280. --- 585,592 -----
  1281.   int LoadXBM(char *, int);
  1282.   int WriteXBM(FILE *, byte *, int, int, char *);
  1283.   
  1284. + /**************************** XVJPEG.C ***************************/
  1285. + int LoadJFIF(char *, int);
  1286.   
  1287.   
  1288.   
  1289. **************
  1290. *** 570,575
  1291.   /****************************** XV.C ****************************/
  1292.   void DrawWindow(), WCrop(), WUnCrop(), WResize(), WRotate(), InvCropRect();
  1293.   void MakeRootPic();
  1294.   
  1295.   /*************************** XVMISC.C ***************************/
  1296.   Window CreateWindow();
  1297. --- 599,605 -----
  1298.   /****************************** XV.C ****************************/
  1299.   void DrawWindow(), WCrop(), WUnCrop(), WResize(), WRotate(), InvCropRect();
  1300.   void MakeRootPic();
  1301. + void XvFreeColors();
  1302.   
  1303.   /*************************** XVMISC.C ***************************/
  1304.   Window CreateWindow();
  1305. **************
  1306. *** 632,636
  1307.   /**************************** XVXBM.C ***************************/
  1308.   int LoadXBM(), WriteXBM();
  1309.   
  1310.   
  1311.   #endif
  1312. --- 662,668 -----
  1313.   /**************************** XVXBM.C ***************************/
  1314.   int LoadXBM(), WriteXBM();
  1315.   
  1316. + /**************************** XVJPEG.C ***************************/
  1317. + int LoadJFIF();
  1318.   
  1319.   #endif
  1320. *** disk$vis:[xv.orig]xv24to8.c
  1321. --- xv24to8.c
  1322. **************
  1323. *** 73,79
  1324.   static int    Quick24to8();
  1325.   static int    QuickCheck();
  1326.   
  1327. ! static byte   tbl1[256],     /* tables used in F-S Dithering */
  1328.                 tbl3[256],     /* contain i/16, 3i/16, 5i/16, 7i/16, */
  1329.                 tbl5[256],     /* (i=0-255) respectively */
  1330.                 tbl7[256];
  1331. --- 73,79 -----
  1332.   static int    Quick24to8();
  1333.   static int    QuickCheck();
  1334.   
  1335. ! static int    tbl1[256],     /* tables used in F-S Dithering */
  1336.                 tbl3[256],     /* contain i/16, 3i/16, 5i/16, 7i/16, */
  1337.                 tbl5[256],     /* (i=-128..127) respectively */
  1338.                 tbl7[256];
  1339. **************
  1340. *** 75,81
  1341.   
  1342.   static byte   tbl1[256],     /* tables used in F-S Dithering */
  1343.                 tbl3[256],     /* contain i/16, 3i/16, 5i/16, 7i/16, */
  1344. !               tbl5[256],     /* (i=0-255) respectively */
  1345.                 tbl7[256];
  1346.   
  1347.   
  1348. --- 75,81 -----
  1349.   
  1350.   static int    tbl1[256],     /* tables used in F-S Dithering */
  1351.                 tbl3[256],     /* contain i/16, 3i/16, 5i/16, 7i/16, */
  1352. !               tbl5[256],     /* (i=-128..127) respectively */
  1353.                 tbl7[256];
  1354.   
  1355.   
  1356. **************
  1357. *** 508,516
  1358.        byte *rp,*gp,*bp;
  1359.   /*******************************/
  1360.   {
  1361. !   *rp = ((ptr->rmin + ptr->rmax) << (COLOR_DEPTH - B_DEPTH)) / 2;
  1362. !   *gp = ((ptr->gmin + ptr->gmax) << (COLOR_DEPTH - B_DEPTH)) / 2;
  1363. !   *bp = ((ptr->bmin + ptr->bmax) << (COLOR_DEPTH - B_DEPTH)) / 2;
  1364.   }
  1365.   
  1366.   
  1367. --- 508,517 -----
  1368.        byte *rp,*gp,*bp;
  1369.   /*******************************/
  1370.   {
  1371. !   /* +1 ensures that color represents the middle of the box */
  1372. !   *rp = ((ptr->rmin + ptr->rmax + 1) << (COLOR_DEPTH - B_DEPTH)) / 2;
  1373. !   *gp = ((ptr->gmin + ptr->gmax + 1) << (COLOR_DEPTH - B_DEPTH)) / 2;
  1374. !   *bp = ((ptr->bmin + ptr->bmax + 1) << (COLOR_DEPTH - B_DEPTH)) / 2;
  1375.   }
  1376.   
  1377.   
  1378. **************
  1379. *** 674,680
  1380.     int           *thisline, *nextline, *tmpptr;
  1381.     int            r1, g1, b1, r2, g2, b2;
  1382.     int            i, j, imax, jmax, oval;
  1383. !   byte          *inptr, *outptr, *tmpbptr;
  1384.     int            lastline, lastpixel;
  1385.   
  1386.     imax = HIGH - 1;
  1387. --- 675,681 -----
  1388.     int           *thisline, *nextline, *tmpptr;
  1389.     int            r1, g1, b1, r2, g2, b2;
  1390.     int            i, j, imax, jmax, oval;
  1391. !   byte          *inptr, *outptr;
  1392.     int            lastline, lastpixel;
  1393.   
  1394.     imax = HIGH - 1;
  1395. **************
  1396. *** 694,701
  1397.     outptr = (byte *) pic;
  1398.   
  1399.     /* get first line of picture */
  1400. !   for (j=WIDE * 3, tmpptr=nextline, tmpbptr=inptr; j; j--) 
  1401. !     *tmpptr++ = (int) *tmpbptr++;
  1402.   
  1403.     for (i=0; i<HIGH; i++) {
  1404.       /* swap thisline and nextline */
  1405. --- 695,702 -----
  1406.     outptr = (byte *) pic;
  1407.   
  1408.     /* get first line of picture */
  1409. !   for (j=WIDE * 3, tmpptr=nextline; j; j--) 
  1410. !     *tmpptr++ = (int) *inptr++;
  1411.   
  1412.     for (i=0; i<HIGH; i++) {
  1413.       /* swap thisline and nextline */
  1414. **************
  1415. *** 703,710
  1416.       lastline = (i==imax);
  1417.   
  1418.       /* read in next line */
  1419. !     for (j=WIDE * 3, tmpptr=nextline; j; j--) 
  1420. !       *tmpptr++ = (int) *inptr++;
  1421.   
  1422.       /* dither this line and put it into the output picture */
  1423.       thisptr = thisline;  nextptr = nextline;
  1424. --- 704,712 -----
  1425.       lastline = (i==imax);
  1426.   
  1427.       /* read in next line */
  1428. !     if (!lastline)
  1429. !       for (j=WIDE * 3, tmpptr=nextline; j; j--) 
  1430. !     *tmpptr++ = (int) *inptr++;
  1431.   
  1432.       /* dither this line and put it into the output picture */
  1433.       thisptr = thisline;  nextptr = nextline;
  1434. **************
  1435. *** 752,758
  1436.         *outptr++ = oval;
  1437.   
  1438.         r1 -= r[oval];  g1 -= g[oval];  b1 -= b[oval];
  1439. -       /* can't use tables because r1,g1,b1 go negative */
  1440.   
  1441.         if (!lastpixel) {
  1442.       thisptr[0] += (r1*7)/16;
  1443. --- 754,759 -----
  1444.         *outptr++ = oval;
  1445.   
  1446.         r1 -= r[oval];  g1 -= g[oval];  b1 -= b[oval];
  1447.   
  1448.         r1 += 128;        /* make positive for table indexing */
  1449.         g1 += 128;
  1450. **************
  1451. *** 754,759
  1452.         r1 -= r[oval];  g1 -= g[oval];  b1 -= b[oval];
  1453.         /* can't use tables because r1,g1,b1 go negative */
  1454.   
  1455.         if (!lastpixel) {
  1456.       thisptr[0] += (r1*7)/16;
  1457.       thisptr[1] += (g1*7)/16;
  1458. --- 755,764 -----
  1459.   
  1460.         r1 -= r[oval];  g1 -= g[oval];  b1 -= b[oval];
  1461.   
  1462. +       r1 += 128;        /* make positive for table indexing */
  1463. +       g1 += 128;
  1464. +       b1 += 128;
  1465. + 
  1466.         if (!lastpixel) {
  1467.       thisptr[0] += tbl7[r1];
  1468.       thisptr[1] += tbl7[g1];
  1469. **************
  1470. *** 755,763
  1471.         /* can't use tables because r1,g1,b1 go negative */
  1472.   
  1473.         if (!lastpixel) {
  1474. !     thisptr[0] += (r1*7)/16;
  1475. !     thisptr[1] += (g1*7)/16;
  1476. !     thisptr[2] += (b1*7)/16;
  1477.         }
  1478.   
  1479.         if (!lastline) {
  1480. --- 760,768 -----
  1481.         b1 += 128;
  1482.   
  1483.         if (!lastpixel) {
  1484. !     thisptr[0] += tbl7[r1];
  1485. !     thisptr[1] += tbl7[g1];
  1486. !     thisptr[2] += tbl7[b1];
  1487.         }
  1488.   
  1489.         if (!lastline) {
  1490. **************
  1491. *** 762,770
  1492.   
  1493.         if (!lastline) {
  1494.       if (j) {
  1495. !       nextptr[-3] += (r1*3)/16;
  1496. !       nextptr[-2] += (g1*3)/16;
  1497. !       nextptr[-1] += (b1*3)/16;
  1498.       }
  1499.   
  1500.       nextptr[0] += (r1*5)/16;
  1501. --- 767,775 -----
  1502.   
  1503.         if (!lastline) {
  1504.       if (j) {
  1505. !       nextptr[-3] += tbl3[r1];
  1506. !       nextptr[-2] += tbl3[g1];
  1507. !       nextptr[-1] += tbl3[b1];
  1508.       }
  1509.   
  1510.       nextptr[0] += tbl5[r1];
  1511. **************
  1512. *** 767,775
  1513.         nextptr[-1] += (b1*3)/16;
  1514.       }
  1515.   
  1516. !     nextptr[0] += (r1*5)/16;
  1517. !     nextptr[1] += (g1*5)/16;
  1518. !     nextptr[2] += (b1*5)/16;
  1519.   
  1520.       if (!lastpixel) {
  1521.         nextptr[3] += r1/16;
  1522. --- 772,780 -----
  1523.         nextptr[-1] += tbl3[b1];
  1524.       }
  1525.   
  1526. !     nextptr[0] += tbl5[r1];
  1527. !     nextptr[1] += tbl5[g1];
  1528. !     nextptr[2] += tbl5[b1];
  1529.   
  1530.       if (!lastpixel) {
  1531.         nextptr[3] += tbl1[r1];
  1532. **************
  1533. *** 772,780
  1534.       nextptr[2] += (b1*5)/16;
  1535.   
  1536.       if (!lastpixel) {
  1537. !       nextptr[3] += r1/16;
  1538. !       nextptr[4] += g1/16;
  1539. !       nextptr[5] += b1/16;
  1540.       }
  1541.       nextptr += 3;
  1542.         }
  1543. --- 777,785 -----
  1544.       nextptr[2] += tbl5[b1];
  1545.   
  1546.       if (!lastpixel) {
  1547. !       nextptr[3] += tbl1[r1];
  1548. !       nextptr[4] += tbl1[g1];
  1549. !       nextptr[5] += tbl1[b1];
  1550.       }
  1551.       nextptr += 3;
  1552.         }
  1553. **************
  1554. *** 807,813
  1555.     byte *pp;
  1556.     int  r1, g1, b1;
  1557.     int  *thisline, *nextline, *thisptr, *nextptr, *tmpptr;
  1558. !   int  i, j, rerr, gerr, berr, pwide3;
  1559.     int  imax, jmax;
  1560.   
  1561.     pp = pic;  pwide3 = w * 3;  imax = h-1;  jmax = w-1;
  1562. --- 812,818 -----
  1563.     byte *pp;
  1564.     int  r1, g1, b1;
  1565.     int  *thisline, *nextline, *thisptr, *nextptr, *tmpptr;
  1566. !   int  i, j, val, pwide3;
  1567.     int  imax, jmax;
  1568.   
  1569.     pp = pic;  pwide3 = w * 3;  imax = h-1;  jmax = w-1;
  1570. **************
  1571. *** 812,818
  1572.   
  1573.     pp = pic;  pwide3 = w * 3;  imax = h-1;  jmax = w-1;
  1574.   
  1575. !   /* load up colormap, 3 bits R, 3 bits G, 2 bits B  (RRRGGGBB) */
  1576.     for (i=0; i<256; i++) {
  1577.       r[i] =  ((i&0xe0) * 255) / 0xe0;  
  1578.       g[i] =  ((i&0x1c) * 255) / 0x1c;
  1579. --- 817,833 -----
  1580.   
  1581.     pp = pic;  pwide3 = w * 3;  imax = h-1;  jmax = w-1;
  1582.   
  1583. !   /* up to 256 colors:     3 bits R, 3 bits G, 2 bits B  (RRRGGGBB) */
  1584. ! #define RMASK    0xe0
  1585. ! #define RSHIFT    0
  1586. ! #define GMASK    0xe0
  1587. ! #define GSHIFT    3
  1588. ! #define BMASK    0xc0
  1589. ! #define BSHIFT    6
  1590. ! 
  1591. !   /* load up colormap */
  1592. !   /* note that 0 and 255 of each color are always in the map; */
  1593. !   /* intermediate values are evenly spaced. */
  1594.     for (i=0; i<256; i++) {
  1595.       r[i] = (((i<<RSHIFT) & RMASK) * 255 + RMASK/2) / RMASK;
  1596.       g[i] = (((i<<GSHIFT) & GMASK) * 255 + GMASK/2) / GMASK;
  1597. **************
  1598. *** 814,822
  1599.   
  1600.     /* load up colormap, 3 bits R, 3 bits G, 2 bits B  (RRRGGGBB) */
  1601.     for (i=0; i<256; i++) {
  1602. !     r[i] =  ((i&0xe0) * 255) / 0xe0;  
  1603. !     g[i] =  ((i&0x1c) * 255) / 0x1c;
  1604. !     b[i] =  ((i&0x03) * 255) / 0x03;
  1605.     }
  1606.   
  1607.     thisline = (int *) malloc(pwide3 * sizeof(int));
  1608. --- 829,837 -----
  1609.     /* note that 0 and 255 of each color are always in the map; */
  1610.     /* intermediate values are evenly spaced. */
  1611.     for (i=0; i<256; i++) {
  1612. !     r[i] = (((i<<RSHIFT) & RMASK) * 255 + RMASK/2) / RMASK;
  1613. !     g[i] = (((i<<GSHIFT) & GMASK) * 255 + GMASK/2) / GMASK;
  1614. !     b[i] = (((i<<BSHIFT) & BMASK) * 255 + BMASK/2) / BMASK;
  1615.     }
  1616.   
  1617.     thisline = (int *) malloc(pwide3 * sizeof(int));
  1618. **************
  1619. *** 840,847
  1620.         r1 = *thisptr++;  g1 = *thisptr++;  b1 = *thisptr++;
  1621.         RANGE(r1,0,255);  RANGE(g1,0,255);  RANGE(b1,0,255);  
  1622.   
  1623. !       rerr = r1 & 0x1f;  gerr = g1 & 0x1f;  berr = b1 & 0x3f;
  1624. !       *pp = (r1&0xe0) | ((g1>>3)&0x1c) | (b1>>6); 
  1625.   
  1626.         if (j!=jmax) {  /* adjust RIGHT pixel */
  1627.       thisptr[0] += tbl7[rerr];
  1628. --- 855,863 -----
  1629.         r1 = *thisptr++;  g1 = *thisptr++;  b1 = *thisptr++;
  1630.         RANGE(r1,0,255);  RANGE(g1,0,255);  RANGE(b1,0,255);  
  1631.   
  1632. !       /* choose actual pixel value */
  1633. !       val = ((r1&RMASK)>>RSHIFT) | ((g1&GMASK)>>GSHIFT) | ((b1&BMASK)>>BSHIFT);
  1634. !       *pp = val;
  1635.   
  1636.         /* compute color errors */
  1637.         r1 -= r[val];
  1638. **************
  1639. *** 843,848
  1640.         rerr = r1 & 0x1f;  gerr = g1 & 0x1f;  berr = b1 & 0x3f;
  1641.         *pp = (r1&0xe0) | ((g1>>3)&0x1c) | (b1>>6); 
  1642.   
  1643.         if (j!=jmax) {  /* adjust RIGHT pixel */
  1644.       thisptr[0] += tbl7[rerr];
  1645.       thisptr[1] += tbl7[gerr];
  1646. --- 859,874 -----
  1647.         val = ((r1&RMASK)>>RSHIFT) | ((g1&GMASK)>>GSHIFT) | ((b1&BMASK)>>BSHIFT);
  1648.         *pp = val;
  1649.   
  1650. +       /* compute color errors */
  1651. +       r1 -= r[val];
  1652. +       g1 -= g[val];
  1653. +       b1 -= b[val];
  1654. + 
  1655. +       /* Add fractions of errors to adjacent pixels */
  1656. +       r1 += 128;        /* make positive for table indexing */
  1657. +       g1 += 128;
  1658. +       b1 += 128;
  1659. + 
  1660.         if (j!=jmax) {  /* adjust RIGHT pixel */
  1661.       thisptr[0] += tbl7[r1];
  1662.       thisptr[1] += tbl7[g1];
  1663. **************
  1664. *** 844,852
  1665.         *pp = (r1&0xe0) | ((g1>>3)&0x1c) | (b1>>6); 
  1666.   
  1667.         if (j!=jmax) {  /* adjust RIGHT pixel */
  1668. !     thisptr[0] += tbl7[rerr];
  1669. !     thisptr[1] += tbl7[gerr];
  1670. !     thisptr[2] += tbl7[berr];
  1671.         }
  1672.         
  1673.         if (i!=imax) {    /* do BOTTOM pixel */
  1674. --- 870,878 -----
  1675.         b1 += 128;
  1676.   
  1677.         if (j!=jmax) {  /* adjust RIGHT pixel */
  1678. !     thisptr[0] += tbl7[r1];
  1679. !     thisptr[1] += tbl7[g1];
  1680. !     thisptr[2] += tbl7[b1];
  1681.         }
  1682.         
  1683.         if (i!=imax) {    /* do BOTTOM pixel */
  1684. **************
  1685. *** 850,858
  1686.         }
  1687.         
  1688.         if (i!=imax) {    /* do BOTTOM pixel */
  1689. !     nextptr[0] += tbl5[rerr];
  1690. !     nextptr[1] += tbl5[gerr];
  1691. !     nextptr[2] += tbl5[berr];
  1692.   
  1693.       if (j>0) {  /* do BOTTOM LEFT pixel */
  1694.         nextptr[-3] += tbl3[rerr];
  1695. --- 876,884 -----
  1696.         }
  1697.         
  1698.         if (i!=imax) {    /* do BOTTOM pixel */
  1699. !     nextptr[0] += tbl5[r1];
  1700. !     nextptr[1] += tbl5[g1];
  1701. !     nextptr[2] += tbl5[b1];
  1702.   
  1703.       if (j>0) {  /* do BOTTOM LEFT pixel */
  1704.         nextptr[-3] += tbl3[r1];
  1705. **************
  1706. *** 855,863
  1707.       nextptr[2] += tbl5[berr];
  1708.   
  1709.       if (j>0) {  /* do BOTTOM LEFT pixel */
  1710. !       nextptr[-3] += tbl3[rerr];
  1711. !       nextptr[-2] += tbl3[gerr];
  1712. !       nextptr[-1] += tbl3[berr];
  1713.       }
  1714.   
  1715.       if (j!=jmax) {  /* do BOTTOM RIGHT pixel */
  1716. --- 881,889 -----
  1717.       nextptr[2] += tbl5[b1];
  1718.   
  1719.       if (j>0) {  /* do BOTTOM LEFT pixel */
  1720. !       nextptr[-3] += tbl3[r1];
  1721. !       nextptr[-2] += tbl3[g1];
  1722. !       nextptr[-1] += tbl3[b1];
  1723.       }
  1724.   
  1725.       if (j!=jmax) {  /* do BOTTOM RIGHT pixel */
  1726. **************
  1727. *** 861,869
  1728.       }
  1729.   
  1730.       if (j!=jmax) {  /* do BOTTOM RIGHT pixel */
  1731. !       nextptr[3] += tbl1[rerr];
  1732. !       nextptr[4] += tbl1[gerr];
  1733. !       nextptr[5] += tbl1[berr];
  1734.       }
  1735.       nextptr += 3;
  1736.         }
  1737. --- 887,895 -----
  1738.       }
  1739.   
  1740.       if (j!=jmax) {  /* do BOTTOM RIGHT pixel */
  1741. !       nextptr[3] += tbl1[r1];
  1742. !       nextptr[4] += tbl1[g1];
  1743. !       nextptr[5] += tbl1[b1];
  1744.       }
  1745.       nextptr += 3;
  1746.         }
  1747. **************
  1748. *** 880,890
  1749.   /****************************/
  1750.   {
  1751.     int i;
  1752. !   for (i=0; i<256; i++) {     /* initialize Floyd-Steinberg division tables */
  1753. !     tbl1[i] = i/16;
  1754. !     tbl3[i] = (3*i)/16;
  1755. !     tbl5[i] = (5*i)/16;
  1756. !     tbl7[i] = (7*i)/16;
  1757.     }
  1758.   }
  1759.   
  1760. --- 906,926 -----
  1761.   /****************************/
  1762.   {
  1763.     int i;
  1764. ! 
  1765. !   /* initialize Floyd-Steinberg division tables */
  1766. !   /* make sure rounding is done correctly for negative values! */
  1767. ! 
  1768. !   for (i = -128; i < 0; i++) {
  1769. !     tbl1[i+128] = -((8 -i  )/16);
  1770. !     tbl3[i+128] = -((8 -3*i)/16);
  1771. !     tbl5[i+128] = -((8 -5*i)/16);
  1772. !     tbl7[i+128] = -((8 -7*i)/16);
  1773. !   }
  1774. !   for (i = 0; i < 128; i++) {
  1775. !     tbl1[i+128] = (i  +8)/16;
  1776. !     tbl3[i+128] = (3*i+8)/16;
  1777. !     tbl5[i+128] = (5*i+8)/16;
  1778. !     tbl7[i+128] = (7*i+8)/16;
  1779.     }
  1780.   }
  1781.   
  1782. *** disk$vis:[xv.orig]xvdir.c
  1783. --- xvdir.c
  1784. **************
  1785. *** 336,342
  1786.   
  1787.     numdirnames = 0;
  1788.   
  1789. ! #ifdef SYSV
  1790.     getcwd(path, sizeof(path));
  1791.   #else
  1792.     getwd(path);
  1793. --- 336,342 -----
  1794.   
  1795.     numdirnames = 0;
  1796.   
  1797. ! #if (defined(SYSV) || defined(SVR4) || defined(VMS))
  1798.     getcwd(path, sizeof(path));
  1799.   #else
  1800.     getwd(path);
  1801. **************
  1802. *** 385,391
  1803.         /* figure out what type of file the beastie is */
  1804.         dirnames[i][0] = C_REG;   /* default to normal file, if lstat fails */
  1805.   
  1806. ! #if defined(i386) || defined (SYSV)
  1807.         if (stat(dirnames[i]+1, &st)==0) {
  1808.   #else
  1809.         if (lstat(dirnames[i]+1, &st)==0) {
  1810. --- 385,391 -----
  1811.         /* figure out what type of file the beastie is */
  1812.         dirnames[i][0] = C_REG;   /* default to normal file, if lstat fails */
  1813.   
  1814. ! #if defined(i386) || defined (SYSV) || defined (VMS)
  1815.         if (stat(dirnames[i]+1, &st)==0) {
  1816.   #else
  1817.         if (lstat(dirnames[i]+1, &st)==0) {
  1818. **************
  1819. *** 425,431
  1820.     RedrawDirW(0,0,DIRWIDE,DIRHIGH);
  1821.   }
  1822.   
  1823. - 
  1824.   /***************************************************/
  1825.   static int dnamcmp(s1,s2)
  1826.   char **s1, **s2;
  1827. --- 425,430 -----
  1828.     RedrawDirW(0,0,DIRWIDE,DIRHIGH);
  1829.   }
  1830.   
  1831.   /***************************************************/
  1832.   static int dnamcmp(s1,s2)
  1833.   char **s1, **s2;
  1834. **************
  1835. *** 539,544
  1836.     /* open file */
  1837.     fp = fopen(filename, "w");
  1838.     if (!fp) {
  1839.       SetISTR(ISTR_INFO,"Can't create '%s' -  %s",filename,sys_errlist[errno]);
  1840.       Warning();
  1841.       if (bwpic) free(bwpic);
  1842. --- 538,546 -----
  1843.     /* open file */
  1844.     fp = fopen(filename, "w");
  1845.     if (!fp) {
  1846. + #ifdef VMS
  1847. +     SetISTR(ISTR_INFO,"Can't create '%s'",filename);
  1848. + #else
  1849.       SetISTR(ISTR_INFO,"Can't create '%s' -  %s",filename,sys_errlist[errno]);
  1850.   #endif
  1851.       Warning();
  1852. **************
  1853. *** 540,545
  1854.     fp = fopen(filename, "w");
  1855.     if (!fp) {
  1856.       SetISTR(ISTR_INFO,"Can't create '%s' -  %s",filename,sys_errlist[errno]);
  1857.       Warning();
  1858.       if (bwpic) free(bwpic);
  1859.       SetCursors(-1);
  1860. --- 542,548 -----
  1861.       SetISTR(ISTR_INFO,"Can't create '%s'",filename);
  1862.   #else
  1863.       SetISTR(ISTR_INFO,"Can't create '%s' -  %s",filename,sys_errlist[errno]);
  1864. + #endif
  1865.       Warning();
  1866.       if (bwpic) free(bwpic);
  1867.       SetCursors(-1);
  1868. *** disk$vis:[xv.orig]xvfish.c
  1869. --- xvfish.c
  1870. **************
  1871. *** 103,108
  1872.   StopFish()
  1873.   /**************/
  1874.   {
  1875.     struct itimerval it;
  1876.   #ifdef POSIX
  1877.     struct sigaction act;
  1878. --- 103,109 -----
  1879.   StopFish()
  1880.   /**************/
  1881.   {
  1882. + #ifndef VMS
  1883.     struct itimerval it;
  1884.   #endif
  1885.   #ifdef POSIX
  1886. **************
  1887. *** 104,109
  1888.   /**************/
  1889.   {
  1890.     struct itimerval it;
  1891.   #ifdef POSIX
  1892.     struct sigaction act;
  1893.   #endif
  1894. --- 105,111 -----
  1895.   {
  1896.   #ifndef VMS
  1897.     struct itimerval it;
  1898. + #endif
  1899.   #ifdef POSIX
  1900.     struct sigaction act;
  1901.   #endif
  1902. **************
  1903. *** 121,126
  1904.   #endif
  1905.   
  1906.   
  1907.     bzero(&it, sizeof(it));
  1908.     it.it_interval.tv_usec = 0L;
  1909.     it.it_value.tv_usec = 0L;
  1910. --- 123,129 -----
  1911.   #endif
  1912.   
  1913.   
  1914. + #ifndef VMS
  1915.     bzero(&it, sizeof(it));
  1916.     it.it_interval.tv_usec = 0L;
  1917.     it.it_value.tv_usec = 0L;
  1918. **************
  1919. *** 135,140
  1920.     RELEASE_SIG;          /* allow ALRM signals to happen (we don't get them) */
  1921.     fishrunning = 0;
  1922.   #endif /* POSIX */  
  1923.   }
  1924.   
  1925.   
  1926. --- 138,144 -----
  1927.     RELEASE_SIG;          /* allow ALRM signals to happen (we don't get them) */
  1928.     fishrunning = 0;
  1929.   #endif /* POSIX */  
  1930. + #endif /* VMS */
  1931.   }
  1932.   
  1933.   
  1934. **************
  1935. *** 177,182
  1936.   static void setfishtimer()
  1937.   /*******/
  1938.   {
  1939.     struct itimerval it;
  1940.   #ifdef POSIX
  1941.     struct sigaction act;
  1942. --- 181,187 -----
  1943.   static void setfishtimer()
  1944.   /*******/
  1945.   {
  1946. + #ifndef VMS
  1947.     struct itimerval it;
  1948.   #endif
  1949.   #ifdef POSIX
  1950. **************
  1951. *** 178,183
  1952.   /*******/
  1953.   {
  1954.     struct itimerval it;
  1955.   #ifdef POSIX
  1956.     struct sigaction act;
  1957.   #endif
  1958. --- 183,189 -----
  1959.   {
  1960.   #ifndef VMS
  1961.     struct itimerval it;
  1962. + #endif
  1963.   #ifdef POSIX
  1964.     struct sigaction act;
  1965.   #endif
  1966. **************
  1967. *** 181,186
  1968.   #ifdef POSIX
  1969.     struct sigaction act;
  1970.   #endif
  1971.        
  1972.     bzero(&it, sizeof(it));
  1973.     it.it_value.tv_usec = DELAY;
  1974. --- 187,193 -----
  1975.   #ifdef POSIX
  1976.     struct sigaction act;
  1977.   #endif
  1978. + #ifndef VMS
  1979.        
  1980.     bzero(&it, sizeof(it));
  1981.     it.it_value.tv_usec = DELAY;
  1982. **************
  1983. *** 193,198
  1984.     RELEASE_SIG;               /* enable ALRM signals */
  1985.     setitimer(ITIMER_REAL, &it, (struct itimerval *)0);
  1986.   #endif /* POSIX */
  1987.   }
  1988.   
  1989.   
  1990. --- 200,206 -----
  1991.     RELEASE_SIG;               /* enable ALRM signals */
  1992.     setitimer(ITIMER_REAL, &it, (struct itimerval *)0);
  1993.   #endif /* POSIX */
  1994. + #endif /* VMS */
  1995.   }
  1996.   
  1997.   
  1998. *** disk$vis:[xv.orig]xvgam.c
  1999. --- xvgam.c
  2000. **************
  2001. *** 620,640
  2002.       LocalCmap = 0;
  2003.     }
  2004.     else {
  2005. !     if (!brokeFreeCols) {
  2006. !       for (i=0; i<nfcols; i++) 
  2007. !     XFreeColors(theDisp, theCmap, &freecols[i], 1, 0L);
  2008. !     }
  2009. !     else {
  2010. !       for (i=0; i<nfcols; i++) {
  2011. !     int j;
  2012. !     for (j=0; j<i; j++) {
  2013. !       if (freecols[i] == freecols[j])   /* already been freed once */
  2014. !         break;
  2015. !     }
  2016. !     if (j==i)      /* wasn't found in already-freed list */
  2017. !       XFreeColors(theDisp, theCmap, &freecols[i], 1, 0L);
  2018. !       }
  2019. !     }
  2020.   
  2021.       if (nfcols) {
  2022.         XFlush(theDisp);  /* just to make sure they're all freed right now... */
  2023. --- 620,626 -----
  2024.       LocalCmap = 0;
  2025.     }
  2026.     else {
  2027. !     XvFreeColors(theDisp, theCmap, freecols, 1, 0L, nfcols);
  2028.   
  2029.       if (nfcols) {
  2030.         XFlush(theDisp);  /* just to make sure they're all freed right now... */
  2031. *** disk$vis:[xv.orig]xvgif.c
  2032. --- xvgif.c
  2033. **************
  2034. *** 88,94
  2035.       /* An output array used by the decompressor */
  2036.   int OutCode[1025];
  2037.   
  2038. ! char *id = "GIF87a";
  2039.   
  2040.   static int EGApalette[16][3] = {
  2041.     {0,0,0},       {0,0,128},     {0,128,0},     {0,128,128}, 
  2042. --- 88,95 -----
  2043.       /* An output array used by the decompressor */
  2044.   int OutCode[1025];
  2045.   
  2046. ! char *id87 = "GIF87a";
  2047. ! char *id89 = "GIF89a";
  2048.   
  2049.   static int EGApalette[16][3] = {
  2050.     {0,0,0},       {0,0,128},     {0,128,0},     {0,128,128}, 
  2051. **************
  2052. *** 140,146
  2053.     if (fread(ptr, filesize, 1, fp) != 1) 
  2054.       return( GifError("GIF data read failed") );
  2055.     
  2056. !   if (strncmp(ptr, id, 6)) 
  2057.       return( GifError("not a GIF file"));
  2058.     
  2059.     ptr += 6;
  2060. --- 141,147 -----
  2061.     if (fread(ptr, filesize, 1, fp) != 1) 
  2062.       return( GifError("GIF data read failed") );
  2063.     
  2064. !   if (strncmp(ptr, id87, 6) && strncmp(ptr, id89, 6)) 
  2065.       return( GifError("not a GIF file"));
  2066.     
  2067.     ptr += 6;
  2068. *** disk$vis:[xv.orig]xvmisc.c
  2069. --- xvmisc.c
  2070. **************
  2071. *** 200,208
  2072.   /************************************************/
  2073.   
  2074.   typedef struct thing 
  2075. !     { byte r,g,b; 
  2076. !       int oldindex; 
  2077. !       int use; } CMAPENT;
  2078.   
  2079.   
  2080.   static int CMAPcompare(a,b)
  2081. --- 200,210 -----
  2082.   /************************************************/
  2083.   
  2084.   typedef struct thing 
  2085. !     { byte r,g,b;        /* actual value of color */
  2086. !       int oldindex;        /* its index in the old colormap */
  2087. !       int use;            /* # of pixels of this color */
  2088. !       int mindist;        /* min distance to a selected color */
  2089. !     } CMAPENT;
  2090.   
  2091.   
  2092.   /***********************************/
  2093. **************
  2094. *** 205,217
  2095.         int use; } CMAPENT;
  2096.   
  2097.   
  2098. - static int CMAPcompare(a,b)
  2099. - CMAPENT *a,*b;
  2100. - {
  2101. -   return (b->use - a->use);
  2102. - }
  2103. - 
  2104. - 
  2105.   /***********************************/
  2106.   void SortColormap()
  2107.   {
  2108. --- 207,212 -----
  2109.       } CMAPENT;
  2110.   
  2111.   
  2112.   /***********************************/
  2113.   void SortColormap()
  2114.   {
  2115. **************
  2116. *** 216,223
  2117.   void SortColormap()
  2118.   {
  2119.     byte *p;
  2120. !   int   i, j, k, mdist, entry, mn, d, hist[256], trans[256];
  2121. !   static CMAPENT c[256], c1[256], *cp, *cj, *ck;
  2122.   
  2123.   
  2124.     /* no point doing this if we're on a 1-bit display */
  2125. --- 211,218 -----
  2126.   void SortColormap()
  2127.   {
  2128.     byte *p;
  2129. !   int   i, j, k, mdist, entry, d, hist[256], trans[256];
  2130. !   CMAPENT c[256], c1[256], *cp, *cj, *ck;
  2131.   
  2132.   
  2133.     /* no point doing this if we're on a 1-bit display */
  2134. **************
  2135. *** 243,248
  2136.         cp = &c[numcols++];
  2137.         cp->r = r[i];  cp->g = g[i];  cp->b = b[i];
  2138.         cp->use = hist[i];  cp->oldindex = i;
  2139.       }
  2140.     }
  2141.   
  2142. --- 238,244 -----
  2143.         cp = &c[numcols++];
  2144.         cp->r = r[i];  cp->g = g[i];  cp->b = b[i];
  2145.         cp->use = hist[i];  cp->oldindex = i;
  2146. +       cp->mindist = 100000;
  2147.       }
  2148.     }
  2149.   
  2150. **************
  2151. *** 256,273
  2152.     c[entry].use = 0;   /* and mark it dealt with */
  2153.     
  2154.     
  2155. !   /* sort rest of colormap, in order of decreasing 'distance' from already
  2156. !      allocated elements.
  2157. !   
  2158. !      FURTHER MODIFICATION of algorithm.  The algorithm's performance
  2159. !      utterly goes to hell as numcols increases.  (Probably on the order
  2160. !      of O^3 performance).  Since I don't see a clever way of rewriting
  2161. !      the algorithm for O^2 performance (which'd be acceptable), I'm going
  2162. !      to make a trade-off.  I'll only run the algorithm for the first 32 colors
  2163. !      (or so).  It can do that Real Fast.  Then I'll just stick the rest of
  2164. !      the unsorted colors (if any), and tack them on the end, in order of
  2165. !      amount of use.  This should give similar picture quality, with 
  2166. !      much higher performance. */
  2167.   
  2168.     for (i=1; i<numcols && i<32; i++) {
  2169.       /* find the i'th most different color */
  2170. --- 252,260 -----
  2171.     c[entry].use = 0;   /* and mark it dealt with */
  2172.     
  2173.     
  2174. !   /* sort rest of colormap.  Half of the entries are allocated on the
  2175. !      basis of distance from already allocated colors, and half on the
  2176. !      basis of usage.  (NB: 'taxicab' distance is used throughout this file.)
  2177.   
  2178.        To obtain O(n^2) performance, we keep each unselected color
  2179.        (in c[], with use>0) marked with the minimum distance to any of
  2180. **************
  2181. *** 269,277
  2182.        amount of use.  This should give similar picture quality, with 
  2183.        much higher performance. */
  2184.   
  2185. !   for (i=1; i<numcols && i<32; i++) {
  2186. !     /* find the i'th most different color */
  2187. !     entry = -1;  mdist = -1;
  2188.       for (j=0, cj=c; j<numcols; j++,cj++) {
  2189.         if (cj->use) {  /* this color has not been marked already */
  2190.       mn = 10000;
  2191. --- 256,269 -----
  2192.        basis of distance from already allocated colors, and half on the
  2193.        basis of usage.  (NB: 'taxicab' distance is used throughout this file.)
  2194.   
  2195. !      To obtain O(n^2) performance, we keep each unselected color
  2196. !      (in c[], with use>0) marked with the minimum distance to any of
  2197. !      the selected colors (in c1[]).  Each time we select a color, we
  2198. !      can update the minimum distances in O(n) time. */
  2199. ! 
  2200. !   for (i=1; i<numcols; i++) {
  2201. !     /* First, update distances to the just-selected color */
  2202. !     ck = &c1[i-1];        /* point to just-selected color */
  2203.       for (j=0, cj=c; j<numcols; j++,cj++) {
  2204.         if (cj->use) {  /* can ignore already-selected colors */
  2205.         d = abs(cj->r - ck->r) + abs(cj->g - ck->g) + abs(cj->b - ck->b);
  2206. **************
  2207. *** 273,281
  2208.       /* find the i'th most different color */
  2209.       entry = -1;  mdist = -1;
  2210.       for (j=0, cj=c; j<numcols; j++,cj++) {
  2211. !       if (cj->use) {  /* this color has not been marked already */
  2212. !     mn = 10000;
  2213. !     for (k=0, ck=c1; k<i; k++,ck++) {
  2214.         d = abs(cj->r - ck->r) + abs(cj->g - ck->g) + abs(cj->b - ck->b);
  2215.         if (mn>d) mn=d;
  2216.       }
  2217. --- 265,271 -----
  2218.       /* First, update distances to the just-selected color */
  2219.       ck = &c1[i-1];        /* point to just-selected color */
  2220.       for (j=0, cj=c; j<numcols; j++,cj++) {
  2221. !       if (cj->use) {  /* can ignore already-selected colors */
  2222.         d = abs(cj->r - ck->r) + abs(cj->g - ck->g) + abs(cj->b - ck->b);
  2223.         if (cj->mindist > d) cj->mindist = d;
  2224.       }
  2225. **************
  2226. *** 277,283
  2227.       mn = 10000;
  2228.       for (k=0, ck=c1; k<i; k++,ck++) {
  2229.         d = abs(cj->r - ck->r) + abs(cj->g - ck->g) + abs(cj->b - ck->b);
  2230. !       if (mn>d) mn=d;
  2231.       }
  2232.       /* mn = minimum distance from c[j] to already used colors */
  2233.       /* we want to select the unused color that has the greatest mn */
  2234. --- 267,273 -----
  2235.       for (j=0, cj=c; j<numcols; j++,cj++) {
  2236.         if (cj->use) {  /* can ignore already-selected colors */
  2237.         d = abs(cj->r - ck->r) + abs(cj->g - ck->g) + abs(cj->b - ck->b);
  2238. !       if (cj->mindist > d) cj->mindist = d;
  2239.       }
  2240.       }
  2241.   
  2242. **************
  2243. *** 279,288
  2244.         d = abs(cj->r - ck->r) + abs(cj->g - ck->g) + abs(cj->b - ck->b);
  2245.         if (mn>d) mn=d;
  2246.       }
  2247. -     /* mn = minimum distance from c[j] to already used colors */
  2248. -     /* we want to select the unused color that has the greatest mn */
  2249. -     if (mn > mdist) { mdist = mn;  entry = j; }
  2250. -       }
  2251.       }
  2252.       
  2253.       /* c[entry] is the next color to put in the map.  do so */
  2254. --- 269,274 -----
  2255.         d = abs(cj->r - ck->r) + abs(cj->g - ck->g) + abs(cj->b - ck->b);
  2256.         if (cj->mindist > d) cj->mindist = d;
  2257.       }
  2258.       }
  2259.   
  2260.       if (i&1) {
  2261. **************
  2262. *** 284,289
  2263.       if (mn > mdist) { mdist = mn;  entry = j; }
  2264.         }
  2265.       }
  2266.       
  2267.       /* c[entry] is the next color to put in the map.  do so */
  2268.       memcpy(&c1[i], &c[entry], sizeof(CMAPENT));
  2269. --- 270,295 -----
  2270.         if (cj->mindist > d) cj->mindist = d;
  2271.       }
  2272.       }
  2273. + 
  2274. +     if (i&1) {
  2275. +       /* Now find the i'th most different color */
  2276. +       /* we want to select the unused color that has the greatest mindist */
  2277. +       entry = -1;  mdist = -1;
  2278. +       for (j=0, cj=c; j<numcols; j++,cj++) {
  2279. +     if (cj->use) {  /* this color has not been marked already */
  2280. +       if (cj->mindist > mdist) { mdist = cj->mindist;  entry = j; }
  2281. +     }
  2282. +       }
  2283. +     } else {
  2284. +       /* Now find the i'th most different color */
  2285. +       /* we want to select the unused color that has the greatest usage */
  2286. +       entry = -1;  mdist = -1;
  2287. +       for (j=0, cj=c; j<numcols; j++,cj++) {
  2288. +     if (cj->use) {  /* this color has not been marked already */
  2289. +       if (cj->use > mdist) { mdist = cj->use;  entry = j; }
  2290. +     }
  2291. +       }
  2292. +     }
  2293.       
  2294.       /* c[entry] is the next color to put in the map.  do so */
  2295.       memcpy(&c1[i], &c[entry], sizeof(CMAPENT));
  2296. **************
  2297. *** 290,300
  2298.       c[entry].use = 0;
  2299.     }
  2300.     
  2301. -   /* tack rest of colors onto colormap in decreasing order of use */
  2302. -   qsort((char *) c,numcols,sizeof(CMAPENT),CMAPcompare);
  2303. -   memcpy(&c1[i], c, (numcols - i) * sizeof(CMAPENT));
  2304. - 
  2305. - 
  2306.     /* build translation table */
  2307.     for (i=0; i<numcols; i++) trans[ c1[i].oldindex ] = i;
  2308.     
  2309. --- 296,301 -----
  2310.       c[entry].use = 0;
  2311.     }
  2312.     
  2313.     /* build translation table */
  2314.     for (i=0; i<numcols; i++) trans[ c1[i].oldindex ] = i;
  2315.     
  2316. **************
  2317. *** 358,363
  2318.        because when I say 'allocate me 32 colors' I want it to allocate
  2319.        32 different colors, not 32 instances of the same 4 shades... */
  2320.     
  2321.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2322.     
  2323.     cmap = theCmap;
  2324. --- 359,367 -----
  2325.        because when I say 'allocate me 32 colors' I want it to allocate
  2326.        32 different colors, not 32 instances of the same 4 shades... */
  2327.     
  2328. + #ifdef VMS
  2329. +   for (i=0; i<numcols; i++) colors[i] = NOPIX;
  2330. + #else
  2331.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2332.   #endif
  2333.     
  2334. **************
  2335. *** 359,364
  2336.        32 different colors, not 32 instances of the same 4 shades... */
  2337.     
  2338.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2339.     
  2340.     cmap = theCmap;
  2341.     for (i=0; i<numcols && unique<ncols; i++) {
  2342. --- 363,369 -----
  2343.     for (i=0; i<numcols; i++) colors[i] = NOPIX;
  2344.   #else
  2345.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2346. + #endif
  2347.     
  2348.     cmap = theCmap;
  2349.     for (i=0; i<numcols && unique<ncols; i++) {
  2350. **************
  2351. *** 370,375
  2352.       if (XAllocColor(theDisp, cmap, &defs[i])) { 
  2353.         unsigned long pixel, *fcptr;
  2354.         
  2355.         pixel = cols[i] = defs[i].pixel;
  2356.         
  2357.         /* see if the newly allocated color is new and different */
  2358. --- 375,383 -----
  2359.       if (XAllocColor(theDisp, cmap, &defs[i])) { 
  2360.         unsigned long pixel, *fcptr;
  2361.         
  2362. + #ifdef VMS
  2363. +       pixel = colors[i] = defs[i].pixel;
  2364. + #else
  2365.         pixel = cols[i] = defs[i].pixel;
  2366.   #endif
  2367.         
  2368. **************
  2369. *** 371,376
  2370.         unsigned long pixel, *fcptr;
  2371.         
  2372.         pixel = cols[i] = defs[i].pixel;
  2373.         
  2374.         /* see if the newly allocated color is new and different */
  2375.         for (j=0, fcptr=freecols; j<nfcols && *fcptr!=pixel; j++,fcptr++);
  2376. --- 379,385 -----
  2377.         pixel = colors[i] = defs[i].pixel;
  2378.   #else
  2379.         pixel = cols[i] = defs[i].pixel;
  2380. + #endif
  2381.         
  2382.         /* see if the newly allocated color is new and different */
  2383.         for (j=0, fcptr=freecols; j<nfcols && *fcptr!=pixel; j++,fcptr++);
  2384. **************
  2385. *** 395,400
  2386.          allocated our own colormap, and have STILL run out of colors
  2387.          (possible, even on an 8 bit display), just mark pixel as
  2388.          unallocated.  We'll deal with it later */
  2389.       cols[i] = NOPIX;
  2390.       }
  2391.     }  /* FIRST PASS */
  2392. --- 404,412 -----
  2393.          allocated our own colormap, and have STILL run out of colors
  2394.          (possible, even on an 8 bit display), just mark pixel as
  2395.          unallocated.  We'll deal with it later */
  2396. + #ifdef VMS
  2397. +     colors[i] = NOPIX;
  2398. + #else
  2399.       cols[i] = NOPIX;
  2400.   #endif
  2401.       }
  2402. **************
  2403. *** 396,401
  2404.          (possible, even on an 8 bit display), just mark pixel as
  2405.          unallocated.  We'll deal with it later */
  2406.       cols[i] = NOPIX;
  2407.       }
  2408.     }  /* FIRST PASS */
  2409.     
  2410. --- 408,414 -----
  2411.       colors[i] = NOPIX;
  2412.   #else
  2413.       cols[i] = NOPIX;
  2414. + #endif
  2415.       }
  2416.     }  /* FIRST PASS */
  2417.     
  2418. **************
  2419. *** 434,439
  2420.     XQueryColors(theDisp, cmap, ctab, dc);
  2421.   
  2422.     for (i=0; i<numcols && unique<ncols; i++)
  2423.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2424.         int           d, mdist, close;
  2425.         unsigned long ri,gi,bi;
  2426. --- 447,455 -----
  2427.     XQueryColors(theDisp, cmap, ctab, dc);
  2428.   
  2429.     for (i=0; i<numcols && unique<ncols; i++)
  2430. + #ifdef VMS
  2431. +     if (colors[i]==NOPIX) {  /* an unallocated pixel */
  2432. + #else
  2433.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2434.   #endif
  2435.         int           d, mdist, close;
  2436. **************
  2437. *** 435,440
  2438.   
  2439.     for (i=0; i<numcols && unique<ncols; i++)
  2440.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2441.         int           d, mdist, close;
  2442.         unsigned long ri,gi,bi;
  2443.   
  2444. --- 451,457 -----
  2445.       if (colors[i]==NOPIX) {  /* an unallocated pixel */
  2446.   #else
  2447.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2448. + #endif
  2449.         int           d, mdist, close;
  2450.         unsigned long ri,gi,bi;
  2451.   
  2452. **************
  2453. *** 451,456
  2454.         if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2455.         if (XAllocColor(theDisp, cmap, &ctab[close])) { 
  2456.       memcpy(&defs[i], &ctab[close], sizeof(XColor));
  2457.       cols[i] = ctab[close].pixel;
  2458.       fc2pcol[nfcols] = i;
  2459.       freecols[nfcols++] = cols[i];
  2460. --- 468,476 -----
  2461.         if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2462.         if (XAllocColor(theDisp, cmap, &ctab[close])) { 
  2463.       memcpy(&defs[i], &ctab[close], sizeof(XColor));
  2464. + #ifdef VMS
  2465. +     colors[i] = ctab[close].pixel;
  2466. + #else
  2467.       cols[i] = ctab[close].pixel;
  2468.   #endif
  2469.       fc2pcol[nfcols] = i;
  2470. **************
  2471. *** 452,457
  2472.         if (XAllocColor(theDisp, cmap, &ctab[close])) { 
  2473.       memcpy(&defs[i], &ctab[close], sizeof(XColor));
  2474.       cols[i] = ctab[close].pixel;
  2475.       fc2pcol[nfcols] = i;
  2476.       freecols[nfcols++] = cols[i];
  2477.       p2alloc++;
  2478. --- 472,478 -----
  2479.       colors[i] = ctab[close].pixel;
  2480.   #else
  2481.       cols[i] = ctab[close].pixel;
  2482. + #endif
  2483.       fc2pcol[nfcols] = i;
  2484.   #ifdef VMS
  2485.       freecols[nfcols++] = colors[i];
  2486. **************
  2487. *** 453,458
  2488.       memcpy(&defs[i], &ctab[close], sizeof(XColor));
  2489.       cols[i] = ctab[close].pixel;
  2490.       fc2pcol[nfcols] = i;
  2491.       freecols[nfcols++] = cols[i];
  2492.       p2alloc++;
  2493.       unique++;
  2494. --- 474,482 -----
  2495.       cols[i] = ctab[close].pixel;
  2496.   #endif
  2497.       fc2pcol[nfcols] = i;
  2498. + #ifdef VMS
  2499. +     freecols[nfcols++] = colors[i];
  2500. + #else
  2501.       freecols[nfcols++] = cols[i];
  2502.   #endif
  2503.       p2alloc++;
  2504. **************
  2505. *** 454,459
  2506.       cols[i] = ctab[close].pixel;
  2507.       fc2pcol[nfcols] = i;
  2508.       freecols[nfcols++] = cols[i];
  2509.       p2alloc++;
  2510.       unique++;
  2511.         }
  2512. --- 478,484 -----
  2513.       freecols[nfcols++] = colors[i];
  2514.   #else
  2515.       freecols[nfcols++] = cols[i];
  2516. + #endif
  2517.       p2alloc++;
  2518.       unique++;
  2519.         }
  2520. **************
  2521. *** 467,472
  2522.        (noglob), or B) the colors found in the X colormap */
  2523.   
  2524.     for (i=0; i<numcols; i++) {
  2525.       if (cols[i] == NOPIX) {  /* an unallocated pixel */
  2526.         int           d, k, mdist, close;
  2527.         unsigned long ri,gi,bi;
  2528. --- 492,500 -----
  2529.        (noglob), or B) the colors found in the X colormap */
  2530.   
  2531.     for (i=0; i<numcols; i++) {
  2532. + #ifdef VMS
  2533. +     if (colors[i] == NOPIX) {  /* an unallocated pixel */
  2534. + #else
  2535.       if (cols[i] == NOPIX) {  /* an unallocated pixel */
  2536.   #endif
  2537.         int           d, k, mdist, close;
  2538. **************
  2539. *** 468,473
  2540.   
  2541.     for (i=0; i<numcols; i++) {
  2542.       if (cols[i] == NOPIX) {  /* an unallocated pixel */
  2543.         int           d, k, mdist, close;
  2544.         unsigned long ri,gi,bi;
  2545.   
  2546. --- 496,502 -----
  2547.       if (colors[i] == NOPIX) {  /* an unallocated pixel */
  2548.   #else
  2549.       if (cols[i] == NOPIX) {  /* an unallocated pixel */
  2550. + #endif
  2551.         int           d, k, mdist, close;
  2552.         unsigned long ri,gi,bi;
  2553.   
  2554. **************
  2555. *** 483,488
  2556.       }
  2557.       if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2558.       memcpy(&defs[i], &ctab[close], sizeof(XColor));
  2559.       cols[i] = defs[i].pixel;
  2560.       p3alloc++;
  2561.         }
  2562. --- 512,520 -----
  2563.       }
  2564.       if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2565.       memcpy(&defs[i], &ctab[close], sizeof(XColor));
  2566. + #ifdef VMS
  2567. +     colors[i] = defs[i].pixel;
  2568. + #else
  2569.       cols[i] = defs[i].pixel;
  2570.   #endif
  2571.       p3alloc++;
  2572. **************
  2573. *** 484,489
  2574.       if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2575.       memcpy(&defs[i], &ctab[close], sizeof(XColor));
  2576.       cols[i] = defs[i].pixel;
  2577.       p3alloc++;
  2578.         }
  2579.         
  2580. --- 516,522 -----
  2581.       colors[i] = defs[i].pixel;
  2582.   #else
  2583.       cols[i] = defs[i].pixel;
  2584. + #endif
  2585.       p3alloc++;
  2586.         }
  2587.         
  2588. **************
  2589. *** 497,502
  2590.       }
  2591.       if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2592.       memcpy(&defs[i], &defs[close], sizeof(XColor));
  2593.       cols[i] = defs[i].pixel;
  2594.         }
  2595.       }
  2596. --- 530,538 -----
  2597.       }
  2598.       if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2599.       memcpy(&defs[i], &defs[close], sizeof(XColor));
  2600. + #ifdef VMS
  2601. +     colors[i] = defs[i].pixel;
  2602. + #else
  2603.       cols[i] = defs[i].pixel;
  2604.   #endif
  2605.         }
  2606. **************
  2607. *** 498,503
  2608.       if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2609.       memcpy(&defs[i], &defs[close], sizeof(XColor));
  2610.       cols[i] = defs[i].pixel;
  2611.         }
  2612.       }
  2613.     }  /* THIRD PASS */
  2614. --- 534,540 -----
  2615.       colors[i] = defs[i].pixel;
  2616.   #else
  2617.       cols[i] = defs[i].pixel;
  2618. + #endif
  2619.         }
  2620.       }
  2621.     }  /* THIRD PASS */
  2622. **************
  2623. *** 538,543
  2624.   
  2625.     cmap = theCmap;
  2626.   
  2627.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2628.   
  2629.     for (i=0; i<numcols && i<ncols; i++) {
  2630. --- 575,583 -----
  2631.   
  2632.     cmap = theCmap;
  2633.   
  2634. + #ifdef VMS
  2635. +   for (i=0; i<numcols; i++) colors[i] = NOPIX;
  2636. + #else
  2637.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2638.   #endif
  2639.   
  2640. **************
  2641. *** 539,544
  2642.     cmap = theCmap;
  2643.   
  2644.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2645.   
  2646.     for (i=0; i<numcols && i<ncols; i++) {
  2647.       unsigned long pmr[1], pix[1];
  2648. --- 579,585 -----
  2649.     for (i=0; i<numcols; i++) colors[i] = NOPIX;
  2650.   #else
  2651.     for (i=0; i<numcols; i++) cols[i] = NOPIX;
  2652. + #endif
  2653.   
  2654.     for (i=0; i<numcols && i<ncols; i++) {
  2655.       unsigned long pmr[1], pix[1];
  2656. **************
  2657. *** 543,548
  2658.     for (i=0; i<numcols && i<ncols; i++) {
  2659.       unsigned long pmr[1], pix[1];
  2660.       if (XAllocColorCells(theDisp, cmap, False, pmr, 0, pix, 1)) {
  2661.         defs[i].pixel = cols[i] = pix[0];
  2662.         defs[i].red   = r[i]<<8;
  2663.         defs[i].green = g[i]<<8;
  2664. --- 584,592 -----
  2665.     for (i=0; i<numcols && i<ncols; i++) {
  2666.       unsigned long pmr[1], pix[1];
  2667.       if (XAllocColorCells(theDisp, cmap, False, pmr, 0, pix, 1)) {
  2668. + #ifdef VMS
  2669. +       defs[i].pixel = colors[i] = pix[0];
  2670. + #else
  2671.         defs[i].pixel = cols[i] = pix[0];
  2672.   #endif
  2673.         defs[i].red   = r[i]<<8;
  2674. **************
  2675. *** 544,549
  2676.       unsigned long pmr[1], pix[1];
  2677.       if (XAllocColorCells(theDisp, cmap, False, pmr, 0, pix, 1)) {
  2678.         defs[i].pixel = cols[i] = pix[0];
  2679.         defs[i].red   = r[i]<<8;
  2680.         defs[i].green = g[i]<<8;
  2681.         defs[i].blue  = b[i]<<8;
  2682. --- 588,594 -----
  2683.         defs[i].pixel = colors[i] = pix[0];
  2684.   #else
  2685.         defs[i].pixel = cols[i] = pix[0];
  2686. + #endif
  2687.         defs[i].red   = r[i]<<8;
  2688.         defs[i].green = g[i]<<8;
  2689.         defs[i].blue  = b[i]<<8;
  2690. **************
  2691. *** 561,566
  2692.       i--;      /* redo the allocation request */
  2693.         }
  2694.   
  2695.         else cols[i] = NOPIX;
  2696.       }
  2697.     }  /* for (i=0; ... */
  2698. --- 606,614 -----
  2699.       i--;      /* redo the allocation request */
  2700.         }
  2701.   
  2702. + #ifdef VMS
  2703. +       else colors[i] = NOPIX;
  2704. + #else
  2705.         else cols[i] = NOPIX;
  2706.   #endif
  2707.       }
  2708. **************
  2709. *** 562,567
  2710.         }
  2711.   
  2712.         else cols[i] = NOPIX;
  2713.       }
  2714.     }  /* for (i=0; ... */
  2715.   
  2716. --- 610,616 -----
  2717.         else colors[i] = NOPIX;
  2718.   #else
  2719.         else cols[i] = NOPIX;
  2720. + #endif
  2721.       }
  2722.     }  /* for (i=0; ... */
  2723.   
  2724. **************
  2725. *** 585,590
  2726.         SetISTR(ISTR_COLOR,"Got %d out of %d colors.",  nfcols,numcols);
  2727.   
  2728.         for (i=0; i<numcols; i++)
  2729.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2730.         int           k, d, mdist, close;
  2731.         unsigned long ri,gi,bi;
  2732. --- 634,642 -----
  2733.         SetISTR(ISTR_COLOR,"Got %d out of %d colors.",  nfcols,numcols);
  2734.   
  2735.         for (i=0; i<numcols; i++)
  2736. + #ifdef VMS
  2737. +     if (colors[i]==NOPIX) {  /* an unallocated pixel */
  2738. + #else
  2739.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2740.   #endif
  2741.         int           k, d, mdist, close;
  2742. **************
  2743. *** 586,591
  2744.   
  2745.         for (i=0; i<numcols; i++)
  2746.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2747.         int           k, d, mdist, close;
  2748.         unsigned long ri,gi,bi;
  2749.   
  2750. --- 638,644 -----
  2751.       if (colors[i]==NOPIX) {  /* an unallocated pixel */
  2752.   #else
  2753.       if (cols[i]==NOPIX) {  /* an unallocated pixel */
  2754. + #endif
  2755.         int           k, d, mdist, close;
  2756.         unsigned long ri,gi,bi;
  2757.   
  2758. **************
  2759. *** 600,605
  2760.         }
  2761.   
  2762.         if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2763.         cols[i] = defs[close].pixel;
  2764.       }
  2765.       }
  2766. --- 653,661 -----
  2767.         }
  2768.   
  2769.         if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2770. + #ifdef VMS
  2771. +       colors[i] = defs[close].pixel;
  2772. + #else
  2773.         cols[i] = defs[close].pixel;
  2774.   #endif
  2775.       }
  2776. **************
  2777. *** 601,606
  2778.   
  2779.         if (close<0) FatalError("This Can't Happen! (How reassuring.)");
  2780.         cols[i] = defs[close].pixel;
  2781.       }
  2782.       }
  2783.   
  2784. --- 657,663 -----
  2785.         colors[i] = defs[close].pixel;
  2786.   #else
  2787.         cols[i] = defs[close].pixel;
  2788. + #endif
  2789.       }
  2790.       }
  2791.   
  2792. **************
  2793. *** 1131,1136
  2794.         else {
  2795.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2796.         if ((i&0x1ffff) == 0) WaitCursor();
  2797.         *ip = (byte) cols[*pp];
  2798.       }
  2799.         }
  2800. --- 1188,1196 -----
  2801.         else {
  2802.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2803.         if ((i&0x1ffff) == 0) WaitCursor();
  2804. + #ifdef VMS
  2805. +       *ip = (byte) colors[*pp];
  2806. + #else
  2807.         *ip = (byte) cols[*pp];
  2808.   #endif
  2809.       }
  2810. **************
  2811. *** 1132,1137
  2812.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2813.         if ((i&0x1ffff) == 0) WaitCursor();
  2814.         *ip = (byte) cols[*pp];
  2815.       }
  2816.         }
  2817.   
  2818. --- 1192,1198 -----
  2819.         *ip = (byte) colors[*pp];
  2820.   #else
  2821.         *ip = (byte) cols[*pp];
  2822. + #endif
  2823.       }
  2824.         }
  2825.   
  2826. **************
  2827. *** 1199,1204
  2828.         for (i=0, pp=epic, lip=imagedata; i<eHIGH; i++, lip+=bperline) {
  2829.           if ((i&127) == 0) WaitCursor();
  2830.           for (j=0, ip=lip, half=0; j<eWIDE; j++,pp++,half++) {
  2831.             if (half&1) { *ip = *ip + ((cols[*pp]&0x0f)<<4);  ip++; }
  2832.             else *ip = cols[*pp]&0x0f;
  2833.           }
  2834. --- 1260,1269 -----
  2835.         for (i=0, pp=epic, lip=imagedata; i<eHIGH; i++, lip+=bperline) {
  2836.           if ((i&127) == 0) WaitCursor();
  2837.           for (j=0, ip=lip, half=0; j<eWIDE; j++,pp++,half++) {
  2838. + #ifdef VMS
  2839. +           if (half&1) { *ip = *ip + ((colors[*pp]&0x0f)<<4);  ip++; }
  2840. +           else *ip = colors[*pp]&0x0f;
  2841. + #else
  2842.             if (half&1) { *ip = *ip + ((cols[*pp]&0x0f)<<4);  ip++; }
  2843.             else *ip = cols[*pp]&0x0f;
  2844.   #endif
  2845. **************
  2846. *** 1201,1206
  2847.           for (j=0, ip=lip, half=0; j<eWIDE; j++,pp++,half++) {
  2848.             if (half&1) { *ip = *ip + ((cols[*pp]&0x0f)<<4);  ip++; }
  2849.             else *ip = cols[*pp]&0x0f;
  2850.           }
  2851.         }
  2852.       }
  2853. --- 1266,1272 -----
  2854.   #else
  2855.             if (half&1) { *ip = *ip + ((cols[*pp]&0x0f)<<4);  ip++; }
  2856.             else *ip = cols[*pp]&0x0f;
  2857. + #endif
  2858.           }
  2859.         }
  2860.       }
  2861. **************
  2862. *** 1207,1212
  2863.       else if (theImage->bits_per_pixel == 8) {
  2864.         for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2865.           if ((i&0x1ffff) == 0) WaitCursor();
  2866.           *ip = (byte) cols[*pp];
  2867.         }
  2868.       }
  2869. --- 1273,1281 -----
  2870.       else if (theImage->bits_per_pixel == 8) {
  2871.         for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2872.           if ((i&0x1ffff) == 0) WaitCursor();
  2873. + #ifdef VMS
  2874. +         *ip = (byte) colors[*pp];
  2875. + #else
  2876.           *ip = (byte) cols[*pp];
  2877.   #endif
  2878.         }
  2879. **************
  2880. *** 1208,1213
  2881.         for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2882.           if ((i&0x1ffff) == 0) WaitCursor();
  2883.           *ip = (byte) cols[*pp];
  2884.         }
  2885.       }
  2886.       else FatalError("This display's too bizarre.  Can't create XImage.");
  2887. --- 1277,1283 -----
  2888.           *ip = (byte) colors[*pp];
  2889.   #else
  2890.           *ip = (byte) cols[*pp];
  2891. + #endif
  2892.         }
  2893.       }
  2894.       else FatalError("This display's too bizarre.  Can't create XImage.");
  2895. **************
  2896. *** 1238,1243
  2897.         else {
  2898.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2899.         if ((i&0x1ffff) == 0) WaitCursor();
  2900.         *ip = (byte) cols[*pp];
  2901.       }
  2902.         }
  2903. --- 1308,1316 -----
  2904.         else {
  2905.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2906.         if ((i&0x1ffff) == 0) WaitCursor();
  2907. + #ifdef VMS
  2908. +       *ip = (byte) colors[*pp];
  2909. + #else
  2910.         *ip = (byte) cols[*pp];
  2911.   #endif
  2912.       }
  2913. **************
  2914. *** 1239,1244
  2915.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++,ip++) {
  2916.         if ((i&0x1ffff) == 0) WaitCursor();
  2917.         *ip = (byte) cols[*pp];
  2918.       }
  2919.         }
  2920.         
  2921. --- 1312,1318 -----
  2922.         *ip = (byte) colors[*pp];
  2923.   #else
  2924.         *ip = (byte) cols[*pp];
  2925. + #endif
  2926.       }
  2927.         }
  2928.         
  2929. **************
  2930. *** 1262,1267
  2931.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++) {
  2932.         if ((i&0x1ffff) == 0) WaitCursor();
  2933.         *ip++ = 0;
  2934.         *ip++ = (cols[*pp]>>16) & 0xff;
  2935.         *ip++ = (cols[*pp]>>8) & 0xff;
  2936.         *ip++ =  cols[*pp] & 0xff;
  2937. --- 1336,1346 -----
  2938.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++) {
  2939.         if ((i&0x1ffff) == 0) WaitCursor();
  2940.         *ip++ = 0;
  2941. + #ifdef VMS
  2942. +       *ip++ = (colors[*pp]>>16) & 0xff;
  2943. +       *ip++ = (colors[*pp]>>8) & 0xff;
  2944. +       *ip++ =  colors[*pp] & 0xff;
  2945. + #else
  2946.         *ip++ = (cols[*pp]>>16) & 0xff;
  2947.         *ip++ = (cols[*pp]>>8) & 0xff;
  2948.         *ip++ =  cols[*pp] & 0xff;
  2949. **************
  2950. *** 1265,1270
  2951.         *ip++ = (cols[*pp]>>16) & 0xff;
  2952.         *ip++ = (cols[*pp]>>8) & 0xff;
  2953.         *ip++ =  cols[*pp] & 0xff;
  2954.       }
  2955.         else 
  2956.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++) {
  2957. --- 1344,1350 -----
  2958.         *ip++ = (cols[*pp]>>16) & 0xff;
  2959.         *ip++ = (cols[*pp]>>8) & 0xff;
  2960.         *ip++ =  cols[*pp] & 0xff;
  2961. + #endif
  2962.       }
  2963.         else 
  2964.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++) {
  2965. **************
  2966. *** 1269,1274
  2967.         else 
  2968.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++) {
  2969.         if ((i&0x1ffff) == 0) WaitCursor();
  2970.         *ip++ =  cols[*pp] & 0xff;
  2971.         *ip++ = (cols[*pp]>>8) & 0xff;
  2972.         *ip++ = (cols[*pp]>>16) & 0xff;
  2973. --- 1349,1359 -----
  2974.         else 
  2975.       for (i=eWIDE*eHIGH, pp=epic, ip=imagedata; i>0; i--,pp++) {
  2976.         if ((i&0x1ffff) == 0) WaitCursor();
  2977. + #ifdef VMS
  2978. +       *ip++ =  colors[*pp] & 0xff;
  2979. +       *ip++ = (colors[*pp]>>8) & 0xff;
  2980. +       *ip++ = (colors[*pp]>>16) & 0xff;
  2981. + #else
  2982.         *ip++ =  cols[*pp] & 0xff;
  2983.         *ip++ = (cols[*pp]>>8) & 0xff;
  2984.         *ip++ = (cols[*pp]>>16) & 0xff;
  2985. **************
  2986. *** 1272,1277
  2987.         *ip++ =  cols[*pp] & 0xff;
  2988.         *ip++ = (cols[*pp]>>8) & 0xff;
  2989.         *ip++ = (cols[*pp]>>16) & 0xff;
  2990.         *ip++ = 0;
  2991.       }
  2992.         }      
  2993. --- 1357,1363 -----
  2994.         *ip++ =  cols[*pp] & 0xff;
  2995.         *ip++ = (cols[*pp]>>8) & 0xff;
  2996.         *ip++ = (cols[*pp]>>16) & 0xff;
  2997. + #endif
  2998.         *ip++ = 0;
  2999.       }
  3000.         }      
  3001. **************
  3002. *** 1571,1576
  3003.   /*******/
  3004.   {
  3005.     long usec;
  3006.     struct itimerval it;
  3007.   
  3008.     if (!n) return;
  3009. --- 1657,1663 -----
  3010.   /*******/
  3011.   {
  3012.     long usec;
  3013. + #ifndef VMS
  3014.     struct itimerval it;
  3015.   #endif
  3016.   
  3017. **************
  3018. *** 1572,1577
  3019.   {
  3020.     long usec;
  3021.     struct itimerval it;
  3022.   
  3023.     if (!n) return;
  3024.     if (fishrunning) { PAUSE_SIG; return; }
  3025. --- 1659,1665 -----
  3026.     long usec;
  3027.   #ifndef VMS
  3028.     struct itimerval it;
  3029. + #endif
  3030.   
  3031.     if (!n) return;
  3032.     if (fishrunning) { PAUSE_SIG; return; }
  3033. **************
  3034. *** 1591,1596
  3035.     return;
  3036.   #endif
  3037.   
  3038.     usec = (long) n * 1000;
  3039.     
  3040.     memset(&it, 0, sizeof(it));
  3041. --- 1679,1685 -----
  3042.     return;
  3043.   #endif
  3044.   
  3045. + #ifndef VMS
  3046.     usec = (long) n * 1000;
  3047.     
  3048.     memset(&it, 0, sizeof(it));
  3049. **************
  3050. *** 1611,1616
  3051.   
  3052.     RELEASE_SIG;                   /* turn ALRM blocking off */
  3053.     signal(SIGALRM,SIG_DFL);
  3054.   }
  3055.   
  3056.   
  3057. --- 1700,1704 -----
  3058.   
  3059.     RELEASE_SIG;                   /* turn ALRM blocking off */
  3060.     signal(SIGALRM,SIG_DFL);
  3061. + #endif  /* VMS */
  3062.   }
  3063. **************
  3064. *** 1612,1620
  3065.     RELEASE_SIG;                   /* turn ALRM blocking off */
  3066.     signal(SIGALRM,SIG_DFL);
  3067.   }
  3068. - 
  3069. - 
  3070. - 
  3071. - 
  3072. - 
  3073. - 
  3074. --- 1702,1704 -----
  3075.     signal(SIGALRM,SIG_DFL);
  3076.   #endif  /* VMS */
  3077.   }
  3078.